riemann-tools 1.1.1 → 1.4.0

data/lib/riemann/tools/health.rb

@@ -2,7 +2,9 @@
 
 require 'riemann/tools'
 require 'riemann/tools/utils'
+require 'riemann/tools/uptime_parser.tab'
 
+# Reports current CPU, disk, load average, and memory use to riemann.
 module Riemann
   module Tools
     class Health
@@ -14,12 +16,18 @@ module Riemann
       opt :disk_warning, 'Disk warning threshold (fraction of space used)', default: 0.9
       opt :disk_critical, 'Disk critical threshold (fraction of space used)', default: 0.95
       opt :disk_ignorefs, 'A list of filesystem types to ignore',
-          default: %w[anon_inodefs autofs cd9660 devfs devtmpfs fdescfs iso9660 linprocfs linsysfs nfs overlay procfs tmpfs]
+          default: %w[anon_inodefs autofs cd9660 devfs devtmpfs fdescfs iso9660 linprocfs linsysfs nfs overlay procfs squashfs tmpfs]
       opt :load_warning, 'Load warning threshold (load average / core)', default: 3.0
       opt :load_critical, 'Load critical threshold (load average / core)', default: 8.0
       opt :memory_warning, 'Memory warning threshold (fraction of RAM)', default: 0.85
       opt :memory_critical, 'Memory critical threshold (fraction of RAM)', default: 0.95
-      opt :checks, 'A list of checks to run.', type: :strings, default: %w[cpu load memory disk]
+      opt :uptime_warning, 'Uptime warning threshold', default: 86_400
+      opt :uptime_critical, 'Uptime critical threshold', default: 3600
+      opt :users_warning, 'Users warning threshold', default: 1
+      opt :users_critical, 'Users critical threshold', default: 1
+      opt :swap_warning, 'Swap warning threshold', default: 0.4
+      opt :swap_critical, 'Swap critical threshold', default: 0.5
+      opt :checks, 'A list of checks to run.', type: :strings, default: %w[cpu load memory disk swap]
 
       def initialize
         @limits = {
@@ -27,6 +35,9 @@ module Riemann
           disk: { critical: opts[:disk_critical], warning: opts[:disk_warning] },
           load: { critical: opts[:load_critical], warning: opts[:load_warning] },
           memory: { critical: opts[:memory_critical], warning: opts[:memory_warning] },
+          uptime: { critical: opts[:uptime_critical], warning: opts[:uptime_warning] },
+          users: { critical: opts[:users_critical], warning: opts[:users_warning] },
+          swap: { critical: opts[:swap_critical], warning: opts[:swap_warning] },
         }
         case (@ostype = `uname -s`.chomp.downcase)
         when 'darwin'
@@ -35,25 +46,32 @@ module Riemann
           @disk = method :disk
           @load = method :darwin_load
           @memory = method :darwin_memory
-          darwin_top
+          @uptime = method :bsd_uptime
+          @swap = method :bsd_swap
         when 'freebsd'
           @cores = `sysctl -n hw.ncpu`.to_i
           @cpu = method :freebsd_cpu
           @disk = method :disk
           @load = method :bsd_load
           @memory = method :freebsd_memory
+          @uptime = method :bsd_uptime
+          @swap = method :bsd_swap
         when 'openbsd'
           @cores = `sysctl -n hw.ncpu`.to_i
           @cpu = method :openbsd_cpu
           @disk = method :disk
           @load = method :bsd_load
           @memory = method :openbsd_memory
+          @uptime = method :bsd_uptime
+          @swap = method :bsd_swap
         when 'sunos'
           @cores = `mpstat -a 2>/dev/null`.split[33].to_i
           @cpu = method :sunos_cpu
           @disk = method :disk
           @load = method :bsd_load
           @memory = method :sunos_memory
+          @uptime = method :bsd_uptime
+          @swap = method :bsd_swap
         else
           @cores = `nproc`.to_i
           puts "WARNING: OS '#{@ostype}' not explicitly supported. Falling back to Linux" unless @ostype == 'linux'
@@ -61,8 +79,11 @@ module Riemann
           @disk = method :disk
           @load = method :linux_load
           @memory = method :linux_memory
+          @uptime = method :linux_uptime
+          @swap = method :linux_swap
           @supports_exclude_type = `df --help 2>&1 | grep -e "--exclude-type"` != ''
         end
+        @users = method :users
 
         opts[:checks].each do |check|
           case check
@@ -74,6 +95,12 @@ module Riemann
             @cpu_enabled = true
           when 'memory'
             @memory_enabled = true
+          when 'uptime'
+            @uptime_enabled = true
+          when 'users'
+            @users_enabled = true
+          when 'swap'
+            @swap_enabled = true
           end
         end
       end
@@ -99,6 +126,30 @@ module Riemann
         end
       end
 
+      def report_int(service, value, report)
+        return unless value
+
+        if value >= @limits[service][:critical]
+          alert service, :critical, value, "#{value} #{report}"
+        elsif value >= @limits[service][:warning]
+          alert service, :warning, value, "#{value} #{report}"
+        else
+          alert service, :ok, value, "#{value} #{report}"
+        end
+      end
+
+      def report_uptime(uptime)
+        description = uptime_to_human(uptime)
+
+        if uptime < @limits[:uptime][:critical]
+          alert 'uptime', :critical, uptime, description
+        elsif uptime < @limits[:uptime][:warning]
+          alert 'uptime', :warning, uptime, description
+        else
+          alert 'uptime', :ok, uptime, description
+        end
+      end
+
       def linux_cpu
         new = File.read('/proc/stat')
         unless new[/cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/]
@@ -205,9 +256,16 @@ module Riemann
         @old_cpu = [u2, s2, t2, i2]
       end
 
+      def uptime_parser
+        @uptime_parser ||= UptimeParser.new
+      end
+
+      def uptime
+        @cached_data[:uptime] ||= uptime_parser.parse(`uptime`)
+      end
+
       def bsd_load
-        m = `uptime`.split(':')[-1].chomp.gsub(/\s+/, '').split(',')
-        load = m[0].to_f / @cores
+        load = uptime[:load_averages][1] / @cores
         if load > @limits[:load][:critical]
           alert 'load', :critical, load, "1-minute load average/core is #{load}"
         elsif load > @limits[:load][:warning]
@@ -240,47 +298,50 @@ module Riemann
       end
 
       def darwin_top
+        return @cached_data[:darwin_top] if @cached_data[:darwin_top]
+
         raw = `top -l 1 | grep -i "^\\(cpu\\|physmem\\|load\\)"`.chomp
-        @topdata = { stamp: Time.now.to_i }
+        topdata = {}
         raw.each_line do |ln|
           if ln.match(/Load Avg: [0-9.]+, [0-9.]+, ([0-9.])+/i)
-            @topdata[:load] = Regexp.last_match(1).to_f
+            topdata[:load] = Regexp.last_match(1).to_f
           elsif ln.match(/CPU usage: [0-9.]+% user, [0-9.]+% sys, ([0-9.]+)% idle/i)
-            @topdata[:cpu] = 1 - (Regexp.last_match(1).to_f / 100)
+            topdata[:cpu] = 1 - (Regexp.last_match(1).to_f / 100)
           elsif (mdat = ln.match(/PhysMem: ([0-9]+)([BKMGT]) wired, ([0-9]+)([BKMGT]) active, ([0-9]+)([BKMGT]) inactive, ([0-9]+)([BKMGT]) used, ([0-9]+)([BKMGT]) free/i))
             wired = mdat[1].to_i * (1024**'BKMGT'.index(mdat[2]))
             active = mdat[3].to_i * (1024**'BKMGT'.index(mdat[4]))
             inactive = mdat[5].to_i * (1024**'BKMGT'.index(mdat[6]))
             used = mdat[7].to_i * (1024**'BKMGT'.index(mdat[8]))
             free = mdat[9].to_i * (1024**'BKMGT'.index(mdat[10]))
-            @topdata[:memory] = (wired + active + used).to_f / (wired + active + used + inactive + free)
+            topdata[:memory] = (wired + active + used).to_f / (wired + active + used + inactive + free)
           # This is for OSX Mavericks which
           # uses a different format for top
           # Example: PhysMem: 4662M used (1328M wired), 2782M unused.
           elsif (mdat = ln.match(/PhysMem: ([0-9]+)([BKMGT]) used \([0-9]+[BKMGT] wired\), ([0-9]+)([BKMGT]) unused/i))
             used = mdat[1].to_i * (1024**'BKMGT'.index(mdat[2]))
             unused = mdat[3].to_i * (1024**'BKMGT'.index(mdat[4]))
-            @topdata[:memory] = used.to_f / (used + unused)
+            topdata[:memory] = used.to_f / (used + unused)
           end
         end
+        @cached_data[:darwin_top] = topdata
       end
 
       def darwin_cpu
-        darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
-        unless @topdata[:cpu]
+        topdata = darwin_top
+        unless topdata[:cpu]
           alert 'cpu', :unknown, nil, 'unable to get CPU stats from top'
           return false
         end
-        report_pct :cpu,  @topdata[:cpu], "usage\n\n#{reverse_numeric_sort_with_header(`ps -eo pcpu,pid,comm`)}"
+        report_pct :cpu, topdata[:cpu], "usage\n\n#{reverse_numeric_sort_with_header(`ps -eo pcpu,pid,comm`)}"
       end
 
       def darwin_load
-        darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
-        unless @topdata[:load]
+        topdata = darwin_top
+        unless topdata[:load]
           alert 'load', :unknown, nil, 'unable to get load ave from top'
           return false
         end
-        metric = @topdata[:load] / @cores
+        metric = topdata[:load] / @cores
         if metric > @limits[:load][:critical]
           alert 'load', :critical, metric, "1-minute load average per core is #{metric}"
         elsif metric > @limits[:load][:warning]
@@ -291,12 +352,12 @@ module Riemann
       end
 
       def darwin_memory
-        darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
-        unless @topdata[:memory]
+        topdata = darwin_top
+        unless topdata[:memory]
           alert 'memory', :unknown, nil, 'unable to get memory data from top'
           return false
         end
-        report_pct :memory, @topdata[:memory], "usage\n\n#{reverse_numeric_sort_with_header(`ps -eo pmem,pid,comm`)}"
+        report_pct :memory, topdata[:memory], "usage\n\n#{reverse_numeric_sort_with_header(`ps -eo pmem,pid,comm`)}"
       end
 
       def df
@@ -336,11 +397,81 @@ module Riemann
         end
       end
 
+      def bsd_uptime
+        value = uptime[:uptime]
+
+        report_uptime(value)
+      end
+
+      def linux_uptime
+        value = File.read('/proc/uptime').split(/\s+/)[0].to_f
+
+        report_uptime(value)
+      end
+
+      def users
+        value = uptime[:users]
+
+        report_int(:users, value, "user#{'s' if value != 1}")
+      end
+
+      def bsd_swap
+        _device, blocks, used, _avail, _capacity = `swapinfo`.lines.last.split(/\s+/)
+
+        value = Float(used) / Integer(blocks)
+
+        report_pct :swap, value, 'used'
+      rescue ArgumentError
+        # Ignore
+      end
+
+      def linux_swap
+        total_size = 0.0
+        total_used = 0.0
+
+        File.read('/proc/swaps').lines.each_with_index do |line, n|
+          next if n.zero?
+
+          _filename, _type, size, used, _priority = line.split(/\s+/)
+
+          total_size += size.to_f
+          total_used += used.to_f
+        end
+
+        return if total_size.zero?
+
+        value = total_used / total_size
+
+        report_pct :swap, value, 'used'
+      end
+
+      def uptime_to_human(value)
+        seconds = value.to_i
+        days = seconds / 86_400
+        seconds %= 86_400
+        hrs = seconds / 3600
+        seconds %= 3600
+        mins = seconds / 60
+        [
+          ("#{days} day#{'s' if days > 1}" unless days.zero?),
+          format('%<hrs>2d:%<mins>02d', hrs: hrs, mins: mins),
+        ].compact.join(' ')
+      end
+
       def tick
+        invalidate_cache
+
         @cpu.call if @cpu_enabled
         @memory.call if @memory_enabled
         @disk.call if @disk_enabled
         @load.call if @load_enabled
+        @uptime.call if @uptime_enabled
+        @users.call if @users_enabled
+        @swap.call if @swap_enabled
+      end
+
+      def invalidate_cache
+        @cached_data = {}
       end
     end
   end

data/lib/riemann/tools/kvm.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+module Riemann
+  module Tools
+    class Kvm
+      include Riemann::Tools
+
+      def tick
+        # determine how many instances I have according to libvirt
+        kvm_instances = `LANG=C virsh list | grep -c running`
+
+        # submit them to riemann
+        report(
+          service: 'KVM Running VMs',
+          metric: kvm_instances.to_i,
+          state: 'info',
+        )
+      end
+    end
+  end
+end

data/lib/riemann/tools/md.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+require 'riemann/tools/mdstat_parser.tab'
+
+module Riemann
+  module Tools
+    class Md
+      include Riemann::Tools
+
+      def mdstat_parser
+        @mdstat_parser ||= MdstatParser.new
+      end
+
+      def tick
+        status = File.read('/proc/mdstat')
+        res = mdstat_parser.parse(status)
+
+        state = res.values.all? { |value| value =~ /\AU+\z/ } ? 'ok' : 'critical'
+
+        report(
+          service: 'mdstat',
+          description: status,
+          state: state,
+        )
+      rescue Errno::ENOENT => e
+        report(
+          service: 'mdstat',
+          description: e.message,
+          state: 'critical',
+        )
+      end
+    end
+  end
+end

data/lib/riemann/tools/mdstat_parser.tab.rb

@@ -0,0 +1,340 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.6.0
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require 'strscan'
+
+module Riemann
+  module Tools
+    class MdstatParser < Racc::Parser
+
+module_eval(<<'...end mdstat_parser.y/module_eval...', 'mdstat_parser.y', 42)
+
+  def parse(text)
+    s = StringScanner.new(text)
+    @tokens = []
+
+    until s.eos? do
+      case
+      when s.scan(/\n/)              then # ignore
+      when s.scan(/\s+/)             then # ignore
+
+      when s.scan(/\[=*>.*\]/)       then @tokens << [:PROGRESS, s.matched]
+      when s.scan(/%/)               then @tokens << ['%', s.matched]
+      when s.scan(/,/)               then @tokens << [',', s.matched]
+      when s.scan(/:/)               then @tokens << [':', s.matched]
+      when s.scan(/</)               then @tokens << ['<', s.matched]
+      when s.scan(/=/)               then @tokens << ['=', s.matched]
+      when s.scan(/>/)               then @tokens << ['>', s.matched]
+      when s.scan(/\(/)              then @tokens << ['(', s.matched]
+      when s.scan(/\)/)              then @tokens << [')', s.matched]
+      when s.scan(/\./)              then @tokens << ['.', s.matched]
+      when s.scan(/\//)              then @tokens << ['/', s.matched]
+      when s.scan(/\[/)              then @tokens << ['[', s.matched]
+      when s.scan(/]/)               then @tokens << [']', s.matched]
+      when s.scan(/algorithm/)       then @tokens << [:ALGORITHM, s.matched]
+      when s.scan(/bitmap/)          then @tokens << [:BITMAP, s.matched]
+      when s.scan(/blocks/)          then @tokens << [:BLOCKS, s.matched]
+      when s.scan(/chunk/)           then @tokens << [:CHUNK, s.matched]
+      when s.scan(/finish/)          then @tokens << [:FINISH, s.matched]
+      when s.scan(/level/)           then @tokens << [:LEVEL, s.matched]
+      when s.scan(/min/)             then @tokens << [:MIN, s.matched]
+      when s.scan(/pages/)           then @tokens << [:PAGES, s.matched]
+      when s.scan(/(raid([014-6]|10)|linear|multipath|faulty)\b/) then @tokens << [:PERSONALITY, s.matched]
+      when s.scan(/Personalities/)   then @tokens << [:PERSONALITIES, s.matched]
+      when s.scan(/recovery/)        then @tokens << [:RECOVERY, s.matched]
+      when s.scan(/speed/)           then @tokens << [:SPEED, s.matched]
+      when s.scan(/super/)           then @tokens << [:SUPER, s.matched]
+      when s.scan(/unused devices/)  then @tokens << [:UNUSED_DEVICES, s.matched]
+      when s.scan(/K\/sec/)          then @tokens << [:SPEED_UNIT, s.matched.to_i]
+      when s.scan(/KB/)              then @tokens << [:BYTE_UNIT, s.matched.to_i]
+      when s.scan(/k/)               then @tokens << [:UNIT, s.matched.to_i]
+      when s.scan(/\d+\.\d+/)        then @tokens << [:FLOAT, s.matched.to_i]
+      when s.scan(/\d+/)             then @tokens << [:INTEGER, s.matched.to_i]
+      when s.scan(/F\b/)             then @tokens << [:FAILED, s.matched.to_i]
+      when s.scan(/\w+/)             then @tokens << [:IDENTIFIER, s.matched]
+      else
+        raise s.rest
+      end
+    end
+
+    do_parse
+  end
+
+  def next_token
+    @tokens.shift
+  end
+...end mdstat_parser.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    10,    13,    14,    10,    29,     3,     4,     6,     7,    15,
+    16,    17,    18,    11,    19,    20,    21,    22,    23,    24,
+    10,    27,    28,    31,    32,    33,    35,    37,    38,    39,
+    40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+    50,    51,    52,    53,    54,    56,    58,    59,    60,    61,
+    62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+    72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+    82,    83,    84,    85,    86,    87,    88 ]
+
+racc_action_check = [
+     5,    10,    10,    25,    25,     0,     1,     3,     4,    11,
+    12,    13,    14,     5,    15,    16,    17,    18,    19,    20,
+    21,    22,    23,    27,    29,    31,    32,    34,    35,    36,
+    37,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+    48,    49,    50,    51,    52,    53,    55,    56,    58,    59,
+    60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
+    70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+    80,    81,    82,    84,    85,    86,    87 ]
+
+racc_action_pointer = [
+   -10,     6,   nil,   -17,     8,   -10,   nil,   nil,   nil,   nil,
+   -23,   -15,   -15,     1,     1,   -19,    -1,     0,    -9,     8,
+    -7,    10,    -7,   -12,   nil,    -7,   nil,    16,   nil,    20,
+   nil,    -4,     5,   nil,    15,    19,     4,    19,   nil,    20,
+     2,     6,    23,    24,    14,    11,    32,    14,    10,    31,
+    40,    17,    33,    42,   nil,    29,    23,   nil,    30,    38,
+    19,    24,    43,    42,    22,    41,    28,    32,    47,    48,
+    33,    56,    51,    37,    35,    35,    58,    56,    37,    64,
+    61,    65,    59,   nil,    54,    43,    64,    56,   nil ]
+
+racc_action_default = [
+   -21,   -21,    -6,   -21,   -21,   -21,    -4,    89,    -1,    -5,
+   -21,   -21,    -2,   -21,   -21,   -21,   -21,   -21,   -21,   -21,
+   -21,   -21,   -11,   -21,    -3,   -21,    -9,   -21,   -20,   -21,
+    -8,   -21,   -13,   -10,   -15,   -21,   -21,   -21,   -12,   -21,
+   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,
+   -21,   -21,   -21,   -17,   -14,   -19,   -21,    -7,   -21,   -21,
+   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,
+   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,   -21,
+   -21,   -21,   -21,   -16,   -21,   -21,   -21,   -21,   -18 ]
+
+racc_goto_table = [
+     9,     1,     2,     5,     8,    12,    25,    34,    36,    55,
+    57,   nil,   nil,   nil,   nil,   nil,    26,   nil,   nil,   nil,
+    30 ]
+
+racc_goto_check = [
+     6,     1,     2,     3,     4,     5,     7,     8,     9,    10,
+    11,   nil,   nil,   nil,   nil,   nil,     6,   nil,   nil,   nil,
+     6 ]
+
+racc_goto_pointer = [
+   nil,     1,     2,     1,    -1,    -1,    -5,   -15,   -25,   -26,
+   -44,   -45 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 36, :_reduce_1,
+  3, 37, :_reduce_none,
+  4, 40, :_reduce_none,
+  0, 40, :_reduce_none,
+  2, 38, :_reduce_5,
+  0, 38, :_reduce_6,
+  19, 41, :_reduce_7,
+  2, 42, :_reduce_none,
+  1, 42, :_reduce_none,
+  7, 41, :_reduce_none,
+  4, 41, :_reduce_none,
+  2, 43, :_reduce_none,
+  0, 43, :_reduce_none,
+  9, 44, :_reduce_none,
+  0, 44, :_reduce_none,
+  14, 45, :_reduce_none,
+  0, 45, :_reduce_none,
+  18, 46, :_reduce_none,
+  0, 46, :_reduce_none,
+  5, 39, :_reduce_none ]
+
+racc_reduce_n = 21
+
+racc_shift_n = 89
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :ALGORITHM => 2,
+  :BITMAP => 3,
+  :BLOCKS => 4,
+  :BYTE_UNIT => 5,
+  :CHUNK => 6,
+  :FAILED => 7,
+  :FINISH => 8,
+  :FLOAT => 9,
+  :IDENTIFIER => 10,
+  :INTEGER => 11,
+  :LEVEL => 12,
+  :MIN => 13,
+  :PAGES => 14,
+  :PERSONALITIES => 15,
+  :PERSONALITY => 16,
+  :PROGRESS => 17,
+  :RECOVERY => 18,
+  :SPEED => 19,
+  :SPEED_UNIT => 20,
+  :SUPER => 21,
+  :UNIT => 22,
+  :UNUSED_DEVICES => 23,
+  ":" => 24,
+  "[" => 25,
+  "]" => 26,
+  "/" => 27,
+  "(" => 28,
+  ")" => 29,
+  "," => 30,
+  "=" => 31,
+  "%" => 32,
+  "<" => 33,
+  ">" => 34 }
+
+racc_nt_base = 35
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "ALGORITHM",
+  "BITMAP",
+  "BLOCKS",
+  "BYTE_UNIT",
+  "CHUNK",
+  "FAILED",
+  "FINISH",
+  "FLOAT",
+  "IDENTIFIER",
+  "INTEGER",
+  "LEVEL",
+  "MIN",
+  "PAGES",
+  "PERSONALITIES",
+  "PERSONALITY",
+  "PROGRESS",
+  "RECOVERY",
+  "SPEED",
+  "SPEED_UNIT",
+  "SUPER",
+  "UNIT",
+  "UNUSED_DEVICES",
+  "\":\"",
+  "\"[\"",
+  "\"]\"",
+  "\"/\"",
+  "\"(\"",
+  "\")\"",
+  "\",\"",
+  "\"=\"",
+  "\"%\"",
+  "\"<\"",
+  "\">\"",
+  "$start",
+  "target",
+  "personalities",
+  "devices",
+  "unused_devices",
+  "list_of_personalities",
+  "device",
+  "list_of_devices",
+  "super",
+  "level",
+  "bitmap",
+  "restore_progress" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'mdstat_parser.y', 3)
+  def _reduce_1(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+module_eval(<<'.,.,', 'mdstat_parser.y', 10)
+  def _reduce_5(val, _values, result)
+     result = val[0].merge(val[1])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'mdstat_parser.y', 11)
+  def _reduce_6(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'mdstat_parser.y', 13)
+  def _reduce_7(val, _values, result)
+     result = { val[0] => val[15] }
+    result
+  end
+.,.,
+
+# reduce 8 omitted
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+# reduce 12 omitted
+
+# reduce 13 omitted
+
+# reduce 14 omitted
+
+# reduce 15 omitted
+
+# reduce 16 omitted
+
+# reduce 17 omitted
+
+# reduce 18 omitted
+
+# reduce 19 omitted
+
+# reduce 20 omitted
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class MdstatParser
+  end   # module Tools
+end   # module Riemann