tweek 0.0.1 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0c0a75d22fc70c3d22e74318e3d957a286d597f
-  data.tar.gz: 5928676675e148473ec09ca0358fd73e6a67d494
+  metadata.gz: bc8acd5816827fe451b4f223f31c70be9862dc25
+  data.tar.gz: 114a4da6ae11f12d5fa23edf7b43419fc0d1a78a
 SHA512:
-  metadata.gz: f1bb49f5fff276b2cbc85ab7b31210e95e1af0e8d77f3762cae9f7cfca08010d06a31fdc3a006ad405aea0ad22a5334a9da699ecf52bd0ef15daa5e17983178c
-  data.tar.gz: 922d61a6cd6c6891f5a6ce8b623a73bd9733c6956c905ba4f332f59d4f3ca248dadc6da2d9b551822212928efbf621d8ac24cfb48c434a00dda4b242dde3797b
+  metadata.gz: 6c69ab3d791fad607f25d4c6361387d3d59ac99467b9d79b2f6a94cf02c29541912c2f8af85fa430ad464b94cdf50a52e84d15f6012d35e91a2ea1753422f58d
+  data.tar.gz: 3b20cc0973d271c4d4a5c06aa4c6d247817cc9cd71d08a22fb8604e97d70dee21508d65b8467f8984c18ca3d643130cc126810fbfdd0215568f726e485845e10

data/bin/tweek

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+#
+# A script to check a variety of Linux system settings
+# See the sample config after __END__ for a description of these.
+# By Nick Townsend, June 2017
+#
+require 'rubygems'
+
+require 'optparse'
+require 'ostruct'
+require 'tweek'
+require 'tweek/app'
+require 'tweek/version'
+
+trap('INT') do
+  print "\n"
+  exit(1)
+end
+
+gflag = 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 "Options:"
+    o.on('--distro=NAME', "Set Distro (default uses lsb_release)" ) do |d|
+        distro = d
+    end
+    o.on('--distro-ver=X.Y.Z', "Set Distro version (default uses lsb_release)" ) do |dv|
+        distro_ver = dv
+    end
+    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
+    end
+    o.on( '-s', '--show', "Write the default parameters to STDOUT",
+          "Use as a fully documented starting point"
+        ) do
+        DATA.each_line{|l| STDOUT.puts l} # no copy_stream in 1.8.7
+        exit
+    end
+    o.on('-v', "--version", "Show version") do
+      puts Tweek::VERSION
+      exit
+    end
+    o.on( '-?', '--help', 'Display this screen' ) do
+        puts o
+        exit
+    end
+    o.separator <<MSG
+
+Returns:
+   0: If no mismatches, >0 number of mismatches
+MSG
+    o.parse! rescue (puts "Error: #{$!}"; puts o; exit)
+end
+if distro.nil? or distro_ver.nil?
+  if RUBY_PLATFORM !~ /-linux-gnu$/
+    STDERR.puts "Tweek only runs on Linux!" 
+    exit 2
+  end 
+  begin
+    distro ||= `lsb_release -i`.partition(':').last.strip
+    distro_ver ||= `lsb_release -r`.partition(':').last.strip
+  rescue
+    puts "'lsb_release' not found! Install or specify --distro and --distro-ver on command line"
+    exit 2
+  end
+end
+if kernel_ver.nil?
+  begin
+    kernel_ver ||= `uname -r`.partition('-').first
+  rescue
+    puts "'uname' not found! Install or specify --kernel-ver on command line"
+    exit 2
+  end
+end
+cs = Tweek::App.new(gflag, true, distro, distro_ver, kernel_ver)
+if ARGV.empty?
+  fh = DATA
+  fh.lineno -= 1
+else
+  fh = ARGF
+end
+cs.read_sections(fh)
+exit cs.results
+
+__END__
+# A documentation-rich sample for the parameter checking script
+#
+# Comments begin with # and extend to the end of the line
+# Block comments are Ruby style =begin and =end
+# Conditionals use 'k' for kernel version, 'v' for distro version and 'd' for distro
+# Version conditionals use the http://guides.rubygems.org/patterns/#semantic-versioning
+# Distro conditionals follow Ruby syntax and you may use string or regex comparisons
+#
+BLKDEV xvda # list one or more block devices here (filename globs OK)
+read_ahead_kb = 1024    # to drive more merged IO
+scheduler = noop        # less CPU wasted stacking an elevator (for SSDs - still for EBS?)
+rq_affinity = 2         # 1 to the CPU group, 2 to the actual CPU
+nr_requests = 256
+
+CLOCKSOURCE # Use cat /sys/devices/system/cl*/cl*/available_clocksource to see what's available
+# xen is the default as supported on all instance types
+# tsc is hardware supported and is significantly quicker, should be used on all post Sandybridge CPUs
+clocksource0 = tsc
+
+KERNEL # Kernel command line parameters
+# true must be present, false must be absent, anything else is a value to be matched
+xen_nopvspin = true
+maxcpus = 63 # Set the number of physical cores, eliminates the 'B' hyperthreads
+# This stops cores idling, eliminating turbo, but decrease latency of core spin-up
+# intel_idle.max_cstate=1
+numa = off if k>3.9 # won't move memory around between NUMA zones, useful with large working set
+
+SYSCTL
+vm.min_free_kbytes = 838608
+vm.zone_reclaim = 1 if k~>4.9.0,d=='Ubuntu'
+vm.zone_reclaim_mode = 1 if k~>3.13.0, k<4.9.0
+
+# These parameters taken from Brendan Gregg's Re:Invent talk 2014
+net.core.somaxconn = 1000
+net.core.netdev_max_backlog = 5000
+net.core.rmem_max = 16777216
+net.core.wmem_max = 16777216
+net.ipv4.tcp_wmem = 4096 12582912 16777216
+net.ipv4.tcp_rmem = 4096 12582912 16777216
+net.ipv4.tcp_max_syn_backlog = 8096
+
+net.ipv4.tcp_slow_start_after_idle = 0
+
+# When making lots of connections to a server enables reuse of a conn in time-wait status,
+# if you run out of slots because of this then packets can get dropped!
+#
+net.ipv4.tcp_tw_reuse = 1
+net.ipv4.ip_local_port_range = 1024 65535
+net.ipv4.tcp_abort_on_overflow = 1  # allows a connection that is queued to be reset, not just dropped.
+net.ipv4.tcp_fin_timeout = 50 if d=~/Amazon|RedHat/i
+
+# Smoother page cache flushing: background flush earlier, aggressive later
+# Brendan Gregg, Re:Invent 2014
+#
+vm.dirty_ratio = 80
+vm.dirty_background_ratio = 5
+vm.dirty_expire_centisecs = 12000
+
+=begin
+# These are all the recommended RedHat TCP settings
+# not yet validated, so used as demo of multiline comments
+net.ipv4.tcp_syn_retries = 0
+net.ipv4.tcp_synack_retries = 0
+net.ipv4.tcp_timestamps = 0
+=end
+
+NET eth0 # Define one or more network devices
+# Check the IRQ strategy:
+# aws:  Use first numa node, split RSS from RPS
+#       RSS allocated across 0-7 (node 0), RPS on first numa node
+# pin:  Differs depending on number of cores
+#    32 Apportion across the single node as follows:
+#       RPS allocated across cores 10-15 and 18-31
+#       RSS allocated across 0-7
+#    64 Use both NUMA nodes, leave first core free on each node
+#       RPS allocated across remaining cores on each node
+#       RSS allocated across 1-4 (node 0) then 17-20 (node 1)
+# null: Ignore this adapter
+irqs = pin
+driver = ena
+# Check values in /sys/class/net/<device>/ tree
+mtu = 9001
+device/driver/module/version = 1.1.3
+
+EXT4 /dev/xvda1 # Define one or more EXT4 devices or mountpoints (filename globs OK)
+# Available parameters are those exposed in /proc/fs/ext4/<device>/options
+
+barrier=true
+stripe=0
+
+XFS /mnt/xfstest # Define one or more XFS devices or mountpoints (filename globs OK)
+# XFS parameters in the form "x.y" where x is log|data|naming|realtime
+# and y is a valid name, eg. data.sunit or log.sunit
+
+data.swidth = 2048
+data.sunit = 128
+data.bsize = 4096
+log.sunit = 1
+
+# vim: ft=ruby ts=8 sw=2 sts=2 et

data/lib/tweek/app.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'optparse'
+require 'ostruct'
+require 'tweek'
+require 'tweek/section'
+
+class Tweek::App
+
+  attr_reader :distro, :distro_version, :kernel_version
+
+  def initialize( gflag, tty, distro, distro_version, kernel_version)
+    @distro = distro
+    @distro_version = Gem::Version.new(distro_version)
+    @kernel_version = Gem::Version.new(kernel_version)
+    @nparams = 0
+    @mismatches = []
+    @errors = []
+    @skips = []
+    @warns = []
+    @generated = []
+    @gflag = gflag
+    @tty = tty
+  end
+
+  # Define data-collection methods so we can easily stub them for tests
+  #
+  def self.bootline
+    @bootline ||= File.open("/proc/cmdline", &:read).chomp rescue 'nowt'
+  end
+
+  def generate type, e
+    return unless @gflag
+    case type
+    when :line
+      @generated.push "#{e.line}#{e.comment}"
+    when :section
+      @generated.push "#{e.type} #{e.list} #{e.comment}"
+    when :entry
+      cond = e.cond.nil? ? "": " if #{e.cond}"
+      comment = e.comment.nil? ? "#": e.comment
+      if e.actual
+        @generated.push "#{e.param} = #{e.actual}#{cond} #{comment} [expected #{e.value}]"
+      else
+        @generated.push "#{e.param} = #{e.value}#{cond} #{comment} [skipped]"
+      end
+    end
+  end
+
+  def error msg
+    @errors.push msg unless @errors.first == msg
+  end
+
+  def messages
+    strings =  @errors + @mismatches
+    return strings.size == 0 ? "": strings.join("\n")
+  end
+
+  def warn msg
+    @warns.push msg unless @warns.first == msg
+  end
+
+  def skipcond entry
+    @skips.push entry
+  end
+
+  def condfail cond
+    return false unless cond
+    failures = 0
+    reqs = cond.split(/\s*,\s*/)
+    reqs.each do |req|
+      ok =  case var = req.slice!(0)
+            when 'k'
+              Gem::Requirement.new(req).satisfied_by?(kernel_version)
+            when 'v'
+              Gem::Requirement.new(req).satisfied_by?(distro_version)
+            when 'd'
+              op = req.slice!(/^[<>~!=]+/)
+              begin
+                eval "distro #{op} #{req}"
+              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 @tty
+      return 0
+    else
+      STDERR.print "F" if @tty
+      @mismatches.push "#{msg}: Expected #{expected}\n#{" "*(msg.size+4)}Actual #{actual}"
+    end
+    return 1
+  end
+
+  # Read the entire file and split into sections
+  #
+  def read_sections handle
+    section = Tweek::Section.new(0,'<initial>','','')
+    while line = handle.gets
+      line.chomp!
+      if (line =~ /^=begin/)..(line =~ /^=end/)
+        section.push OpenStruct.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 )
+        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)
+        next
+      end
+
+      if /^\s*(.+?)\s*=\s*(.*?)\s*(if\s+(.*))?$/ =~ line
+        section.push OpenStruct.new( :lineno => handle.lineno, :param => $1, :value => $2,
+                                     :cond => $4, :comment => comment )
+        next
+      end
+      error "#{handle.lineno}: Unrecognized line: #{line}"
+    end
+    section.process(self)
+
+  end
+
+  def results
+    STDERR.puts "\nDistro: #{@distro} Version: #{@distro_version} Kernel: #{@kernel_version}"
+    STDERR.puts "\n#{@nparams} parameters checked, #{@skips.size} skipped, #{@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}
+    return @mismatches.size
+  end
+end

data/lib/tweek/section.rb

@@ -0,0 +1,252 @@
+# 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
+#
+class Tweek::Section < Array
+
+  attr_reader :lineno, :type, :list, :comment
+  def initialize lineno, type, list, comment
+    @lineno = lineno
+    @type = type
+    @list = list
+    @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
+    self.each do |entry|
+      if entry.line
+        cs.generate :line, entry
+        next
+      end
+      begin
+        if cs.condfail entry.cond
+          cs.generate :entry, entry
+          cs.skipcond entry
+          next
+        end
+        yield entry
+      rescue Exception => e
+        cs.error "#{entry.lineno}: #{e.message}"
+      end
+    end
+  end
+
+  def process cs
+
+    cs.generate :section, section_entry unless type == '<initial>'
+
+    return if self.empty?
+
+    case type
+    when '<initial>'
+        each_entry (cs) do |entry|
+        end
+
+    when 'BLKDEV' # BLOCK DEVICE PARAMETERS
+
+      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?
+
+      devices.each do |blk|
+        each_entry (cs) do |entry|
+          entry.actual = File.open("/sys/block/#{blk}/queue/#{entry.param}", &:read).chomp rescue $!.message
+          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
+        end
+      end
+
+    when 'KERNEL' # KERNEL PARAMETERS
+      each_entry (cs) do |entry|
+        actual = /\b(#{entry.param})(=\S+)?\b/.match(Tweek::App.bootline)
+        case
+        when (entry.value == 'true' and actual)
+          observed = actual.to_s
+          expected = entry.param
+        when (entry.value == 'true' and actual.nil?)
+          expected = 'to be found'
+          observed = 'was not found'
+        when (entry.value == 'false' and actual)
+          expected = 'to not be found'
+          observed = 'was found'
+        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]
+        end
+        cs.assert_equal expected, observed, "Kernel parameter #{entry.param}"
+        entry.actual = !actual.nil?
+        cs.generate :entry, entry
+      end
+
+    when 'CLOCKSOURCE'
+      each_entry (cs) do |entry|
+        entry.actual=File.open("/sys/devices/system/clocksource/#{entry.param}/current_clocksource",&:read).chomp rescue $!.message
+        cs.assert_equal entry.value, entry.actual, entry.param
+        cs.generate :entry, entry
+      end
+
+    when 'SYSCTL' # SYSCTL SETTINGS
+      each_entry (cs) do |entry|
+        file = entry.param.gsub(/\./,'/')
+        entry.actual = File.open("/proc/sys/#{file}", &:read).chomp.gsub(/\s+/,' ') rescue $!.message
+        cs.assert_equal entry.value, entry.actual, entry.param
+        cs.generate :entry, entry
+      end
+
+    when 'NET'  # NETWORK DEVICES
+      devices = self.list.split(' ').map{|dev| dev.gsub(/^\/dev\//,'')}
+      cs.warn "Network device check skipped: no devices found" if devices.empty?
+
+      devices.each do |netdev|
+        each_entry (cs) do |entry|
+
+	  case entry.param
+	  when 'driver'
+	    entry.actual = File.basename(File.readlink("/sys/class/net/#{netdev}/device/driver"))
+	    cs.assert_equal entry.value, entry.actual, entry.param
+
+	  when 'irqs'
+
+	    irqs=File.open("/proc/interrupts", &:readlines).grep(/\b#{netdev}\b/).map{|m| m.partition(':')[0].strip}
+
+	    if irqs.empty?
+	      cs.warn "#{netdev} IRQ check skipped: none found"
+	      entry.actual = 'null'
+	      cs.generate :entry, entry
+	      next
+	    end
+
+	    ncores = `getconf _NPROCESSORS_ONLN`.chomp.to_i rescue 0
+	    mismatches = 0
+	    irqs.each_with_index do |irq, ix|
+	      case entry.value
+	      when 'null','none','ignore'
+		next
+
+	      when 'aws'
+		expected_rps = ("00000000," * 3) + "0000ff00"
+		expected_rss = ("00000000," * 3) + sprintf("%08x", 1<<ix)
+
+	      when 'pin'
+		case ncores
+		when 32 # RPS on cores 10-15 and 18-31, RSS tied to 0-7
+		  case ix
+		  when 0..7
+		    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}"
+		  end
+
+		when 64 # Split the work across the two nodes
+		  case ix
+		  when 0..3 # alloc on node 0 (cpus 0-3)
+		    expected_rps = ("00000000," * 2) + "0000ffff," + "0000ffe0"
+		    expected_rss = ("00000000," * 3) + sprintf("%08x", 1<<(ix+1))
+		  when 4..7 # alloc on node 1 (
+		    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}"
+		  end
+
+		else
+		  cs.error "#{entry.lineno}: Can't handle #{ncores} cores in IRQ strategy '#{entry.value}'"
+		end
+
+	      else
+		cs.error "#{entry.lineno}: Unrecognized #{netdev} IRQ strategy '#{entry.value}'"
+	      end
+	      actual_rss = File.open("/proc/irq/#{irq}/smp_affinity",&:read).chomp rescue $!.message
+	      actual_rps = File.open("/sys/class/net/#{netdev}/queues/rx-#{ix}/rps_cpus", &:read).chomp rescue $!.message
+	      mismatches += cs.assert_equal expected_rss, actual_rss, "#{netdev}_irq_#{irq}_rss"
+	      mismatches += cs.assert_equal expected_rps, actual_rps, "#{netdev}_irq_#{irq}_rps"
+	    end
+	    entry.actual = 'null' if mismatches > 0
+
+	  else # try getting the name
+	    begin
+	      entry.actual = File.open("/sys/class/net/#{netdev}/#{entry.param}", &:read).chomp.gsub(/\s+/,' ')
+	      cs.assert_equal entry.value, entry.actual, entry.param
+
+	    rescue
+	      cs.error "#{entry.lineno}: Network parameter #{entry.param} not handled: #{$!.message}"
+	      next
+	    end
+          end
+	  cs.generate :entry, entry
+        end
+      end
+
+    when 'EXT4' # EXT4 filesystems info via `dumpe2fs -h /dev/#{device}`
+      mounted = File.open("/proc/mounts", &:readlines).map{|m| m.split(' ')}
+      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"
+          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|
+          entry.actual = options[entry.param] || "<not found>"
+          cs.assert_equal entry.value, entry.actual, "EXT4 #{mount}: #{entry.param}"
+          cs.generate :entry, entry
+        end
+      end
+
+    when 'XFS' # XFS filesystems info  via `xfs_info`
+      # Dynamically via: /proc/fs/xfs/... ?
+      mounts = self.list.split(' ')
+      if mounts.empty?
+        cs.warn "#{self.lineno}: XFS device check skipped: no mountpoints found"
+      end
+      mounts.each do |mount|
+        xfsinfo = `xfs_info #{mount} 2>/dev/null`.chomp
+        if $?.exitstatus > 0
+          cs.warn "No XFS filesystem at #{mount}"
+          each_entry (cs) { |entry| cs.generate :entry, entry }
+          next
+        end
+        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 (cs) 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
+        end
+      end
+
+    else
+      cs.error "#{self.lineno}: Unknown type #{self.type}"
+    end
+
+  end
+end
+

data/lib/tweek/version.rb

@@ -1,3 +1,3 @@
 module Tweek
-  VERSION = "0.0.1"
+  VERSION = "0.9.5"
 end

data/lib/tweek.rb

@@ -1,5 +1,3 @@
-require "tweek/version"
-
 module Tweek
-  # Your code goes here...
+  # nothing yet
 end

data/tweek.gemspec

@@ -12,8 +12,6 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Read and compare Linux parameters for performance tweaking}
   spec.license       = "MIT"
 
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
     spec.metadata["allowed_push_host"] = "https://rubygems.org"
   else
@@ -24,8 +22,8 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = "bin"
+  spec.executables   = ['tweek']
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.15"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tweek
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.9.5
 platform: ruby
 authors:
 - Nick Townsend
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2017-09-14 00:00:00.000000000 Z
+date: 2017-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,7 +55,8 @@ dependencies:
 description: 
 email:
 - nick.townsend@mac.com
-executables: []
+executables:
+- tweek
 extensions: []
 extra_rdoc_files: []
 files:
@@ -68,7 +69,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/tweek
 - lib/tweek.rb
+- lib/tweek/app.rb
+- lib/tweek/section.rb
 - lib/tweek/version.rb
 - tweek.gemspec
 homepage: