RubyGems - ustate-client - Versions diffs - 0.0.1 - Mend

ustate-client 0.0.1

Files changed (28) hide show

data/LICENSE +21 -0
data/README.markdown +111 -0
data/lib/ustate/client/query.rb +17 -0
data/lib/ustate/client.rb +108 -0
data/lib/ustate/dash/config.rb +0 -0
data/lib/ustate/dash/controller/css.rb +5 -0
data/lib/ustate/dash/controller/index.rb +5 -0
data/lib/ustate/dash/helper/renderer.rb +209 -0
data/lib/ustate/dash/state.rb +75 -0
data/lib/ustate/dash/views/css.scss +39 -0
data/lib/ustate/dash/views/index.erubis +3 -0
data/lib/ustate/dash/views/layout.erubis +16 -0
data/lib/ustate/dash.rb +111 -0
data/lib/ustate/message.rb +16 -0
data/lib/ustate/query.rb +7 -0
data/lib/ustate/query_string.rb +1066 -0
data/lib/ustate/query_string.treetop +116 -0
data/lib/ustate/server/backends/base.rb +103 -0
data/lib/ustate/server/backends/tcp.rb +33 -0
data/lib/ustate/server/backends.rb +4 -0
data/lib/ustate/server/connection.rb +82 -0
data/lib/ustate/server/graphite.rb +11 -0
data/lib/ustate/server/index.rb +134 -0
data/lib/ustate/server.rb +66 -0
data/lib/ustate/state.rb +18 -0
data/lib/ustate/version.rb +3 -0
data/lib/ustate.rb +9 -0
metadata +71 -0

data/lib/ustate/dash/state.rb ADDED Viewed

@@ -0,0 +1,75 @@
+class UState::State
+  # Average a set of states together. Chooses the meane metric, the mode
+  # state, and the mean time. If init is provided, its values override (where present) the
+  # computed ones.
+  def average(states, init = State.new)
+    # Metric
+    init.metric ||= begin
+      states.inject(0) { |a, state|
+        a + (state.metric || 0)
+      } / states.size
+    rescue
+      nil
+    end
+    # State
+    init.state ||= states.inject(Hash.new(0)) do |counts, s|
+      counts[s.state] += 1
+      counts
+    end.sort_by { |state, count| count }.first.first rescue nil
+    init.time ||= begin
+      states.inject(0) do |a, state|
+        a + state.time.to_f
+      end / states.size
+    rescue
+    end
+    init
+  end
+  # Finds the maximum of a set of states. Metric is the maximum. State is the highest,
+  # as defined by Dash.config.state_order. Time is the mean.
+  def max(states, init = {})
+    init.metric ||= states.inject(0) { |a, state|
+        a + (state.metric || 0)
+      }
+    init.state] ||= states.inject(nil) do |max, state|
+      state.state if Dash.config[:state_order][state.state] > Dash.config[:state_order][max]
+    end
+    init.time ||= begin
+      states.inject(0) { |a, state|
+        a + state.time.to_f
+      } / states.size
+    rescue
+      nil
+    end
+    init
+  end
+  # Partition a list of states by a field
+  # Returns a hash of field_value => state
+  def partition(states, field)
+    states.inject(Hash.new { [] }) do |p, state|
+      p[state.send(field)] << state
+    end
+  end
+  # Sorts states by a field. nil values first.
+  def sort(states, field)
+    states.sort do |a, b|
+      a = a.send field
+      b = b.send field
+      if a.nil?
+        -1
+      elsif b.nil?
+        1
+      else
+        a <=> b
+      end
+    end
+  end
+end

data/lib/ustate/dash/views/css.scss ADDED Viewed

@@ -0,0 +1,39 @@
+html,table {
+  font-family: Helvetica Nueue, Helvetica, sans;
+  font-size: 8pt;
+}
+h1 {
+  margin-bottom: 0.2em;
+}
+h2 {
+  margin-top: 0;
+  margin-bottom: 0.1em;
+}
+.box {
+  float: left;
+  margin: 4px;
+}
+.ok {
+  background: #B8F1BC;
+}
+.warning {
+  background: #F7D18E;
+}
+.critical {
+  background: #FF3C43;
+}
+.chart {
+  width: 140px;
+  border: 1px solid #ccc;
+}
+.chart td {
+  min-width: 40px;
+  overflow: hidden;
+}
+.chart th {
+  width: 1px;
+  text-align: left;
+}

data/lib/ustate/dash/views/index.erubis ADDED Viewed

@@ -0,0 +1,3 @@
+<div class="box"><%= state_list query 'state != "ok"' %></div>
+<div class="box"><%= state_chart query 'service = "cpu" or service = "memory" or service =~ "disk%" or service = "load"' %></div>

data/lib/ustate/dash/views/layout.erubis ADDED Viewed

@@ -0,0 +1,16 @@
+<html>
+<head>
+  <title>Dashboard</title>
+  <meta http-equiv="refresh" content="1" />
+  <link rel="stylesheet" type="text/css" href="/css" />
+</head>
+<body>
+  <div>
+    <h1>Dashboard</h1>
+    <span style="position: absolute; top: 4px; right: 4px;">(as of <%= time Time.now.to_i %>)</span>
+  </div>
+  <%= yield %>
+</body>
+</html>

data/lib/ustate/dash.rb ADDED Viewed

@@ -0,0 +1,111 @@
+require 'sinatra/base'
+module UState
+  class Dash < Sinatra::Base
+    # A little dashboard sinatra application.
+    require 'yaml'
+    require 'find'
+    require 'ustate/client'
+    require 'erubis'
+    require 'sass'
+    def self.config
+      @config ||= {
+        client: {},
+        age_scale: 60 * 30,
+        state_order: {
+          'critical' => 3,
+          'warning' => 2,
+          'ok' => 1
+        },
+        strftime: '%H:%M:%S',
+        controllers: [File.join(File.dirname(__FILE__), 'dash', 'controller')],
+        helpers: [File.join(File.dirname(__FILE__), 'dash', 'helper')],
+        views: 'views'
+      }
+    end
+    def self.client
+      @client ||= UState::Client.new(config[:client])
+    end
+    def self.load
+      load_config
+      config[:controllers].each { |d| load_controllers d }
+      config[:helpers].each { |d| load_helpers d }
+      set :views, File.expand_path(config[:views])
+    end
+    # Executes the configuration file.
+    def self.load_config
+      instance_eval File.read('config.rb')
+    end
+    # Load controllers.
+    # Controllers can be regular old one-file-per-class, but if you prefer a little
+    # more modularity, this method will allow you to define all controller methods
+    # in their own files.  For example, get "/posts/*/edit" can live in
+    # controller/posts/_/edit.rb. The sorting system provided here requires
+    # files in the correct order to handle wildcards appropriately.
+    def self.load_controllers(dir)
+      rbs = []
+      Find.find(
+        File.expand_path(dir)
+      ) do |path|
+        rbs << path if path =~ /\.rb$/
+      end
+      # Sort paths with _ last, becase those are wildcards.
+      rbs.sort! do |a, b|
+        as = a.split File::SEPARATOR
+        bs = b.split File::SEPARATOR
+        # Compare common subpaths
+        l = [as.size, bs.size].min
+        catch :x do
+          (0...l).each do |i|
+            a, b = as[i], bs[i]
+            if a[/^_/] and not b[/^_/]
+              throw :x, 1
+            elsif b[/^_/] and not a[/^_/]
+              throw :x, -1
+            elsif ord = (a <=> b) and ord != 0
+              throw :x, ord
+            end
+          end
+          # All subpaths are identical; sort longest first
+          if as.size > bs.size
+            throw :x, -1
+          elsif as.size < bs.size
+            throw :x, -1
+          else
+            throw :x, 0
+          end
+        end
+      end
+      rbs.each do |r|
+        require r
+      end
+    end
+    # Load helpers
+    def self.load_helpers(dir)
+      Find.find(
+        File.expand_path(dir)
+      ) do |path|
+        require path if path =~ /\.rb$/
+      end
+    end
+    def client
+      self.class.client
+    end
+    def query(*a)
+      self.class.client.query(*a).states || []
+    end
+  end
+end

data/lib/ustate/message.rb ADDED Viewed

@@ -0,0 +1,16 @@
+module UState
+  class Message
+    include Beefcake::Message
+    optional :ok, :bool, 2
+    optional :error, :string, 3
+    repeated :states, State, 4
+    optional :query, Query, 5
+    def encode_with_length
+      buffer = ''
+      encoded = encode buffer
+      "#{[encoded.length].pack('N')}#{encoded}"
+    end
+  end
+end

data/lib/ustate/query.rb ADDED Viewed

@@ -0,0 +1,7 @@
+module UState
+  class Query
+    include Beefcake::Message
+    optional :string, :string, 1
+  end
+end

data/lib/ustate/query_string.rb ADDED Viewed

@@ -0,0 +1,1066 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+module UState
+  module QueryString
+    include Treetop::Runtime
+    def root
+      @root ||= :or
+    end
+    module Or0
+      def space1
+        elements[0]
+      end
+      def space2
+        elements[2]
+      end
+      def and
+        elements[3]
+      end
+    end
+    module Or1
+      def first
+        elements[0]
+      end
+      def rest
+        elements[1]
+      end
+    end
+    module Or2
+      def sql
+        rest.elements.map { |x| x.and }.
+          inject(first.sql) do |a, sub|
+            a | sub.sql
+          end
+      end
+    end
+    def _nt_or
+      start_index = index
+      if node_cache[:or].has_key?(index)
+        cached = node_cache[:or][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      r1 = _nt_and
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r4 = _nt_space
+          s3 << r4
+          if r4
+            if has_terminal?('or', false, index)
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure('or')
+              r5 = nil
+            end
+            s3 << r5
+            if r5
+              r6 = _nt_space
+              s3 << r6
+              if r6
+                r7 = _nt_and
+                s3 << r7
+              end
+            end
+          end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Or0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Or1)
+        r0.extend(Or2)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:or][start_index] = r0
+      r0
+    end
+    module And0
+      def space1
+        elements[0]
+      end
+      def space2
+        elements[2]
+      end
+      def primary
+        elements[3]
+      end
+    end
+    module And1
+      def first
+        elements[0]
+      end
+      def rest
+        elements[1]
+      end
+    end
+    module And2
+      def sql
+        rest.elements.map { |x| x.primary }.
+          inject(first.sql) do |a, sub|
+            a & sub.sql
+          end
+      end
+    end
+    def _nt_and
+      start_index = index
+      if node_cache[:and].has_key?(index)
+        cached = node_cache[:and][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      r1 = _nt_primary
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r4 = _nt_space
+          s3 << r4
+          if r4
+            if has_terminal?('and', false, index)
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 3))
+              @index += 3
+            else
+              terminal_parse_failure('and')
+              r5 = nil
+            end
+            s3 << r5
+            if r5
+              r6 = _nt_space
+              s3 << r6
+              if r6
+                r7 = _nt_primary
+                s3 << r7
+              end
+            end
+          end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(And0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(And1)
+        r0.extend(And2)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:and][start_index] = r0
+      r0
+    end
+    module Primary0
+      def x
+        elements[2]
+      end
+    end
+    module Primary1
+      def sql
+        x.sql
+      end
+    end
+    def _nt_primary
+      start_index = index
+      if node_cache[:primary].has_key?(index)
+        cached = node_cache[:primary][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0 = index
+      i1, s1 = index, []
+      if has_terminal?('(', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('(')
+        r2 = nil
+      end
+      s1 << r2
+      if r2
+        r4 = _nt_space
+        if r4
+          r3 = r4
+        else
+          r3 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r3
+        if r3
+          r5 = _nt_or
+          s1 << r5
+          if r5
+            r7 = _nt_space
+            if r7
+              r6 = r7
+            else
+              r6 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s1 << r6
+            if r6
+              if has_terminal?(')', false, index)
+                r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(')')
+                r8 = nil
+              end
+              s1 << r8
+            end
+          end
+        end
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(Primary0)
+        r1.extend(Primary1)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        r9 = _nt_predicate
+        if r9
+          r0 = r9
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+      node_cache[:primary][start_index] = r0
+      r0
+    end
+    def _nt_predicate
+      start_index = index
+      if node_cache[:predicate].has_key?(index)
+        cached = node_cache[:predicate][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0 = index
+      r1 = _nt_equals
+      if r1
+        r0 = r1
+      else
+        r2 = _nt_not_equals
+        if r2
+          r0 = r2
+        else
+          r3 = _nt_approximately
+          if r3
+            r0 = r3
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+      node_cache[:predicate][start_index] = r0
+      r0
+    end
+    module Approximately0
+      def field
+        elements[0]
+      end
+      def string
+        elements[4]
+      end
+    end
+    module Approximately1
+      def sql
+        Sequel::SQL::StringExpression.like field.sql, string.sql
+      end
+    end
+    def _nt_approximately
+      start_index = index
+      if node_cache[:approximately].has_key?(index)
+        cached = node_cache[:approximately][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      r1 = _nt_field
+      s0 << r1
+      if r1
+        r3 = _nt_space
+        if r3
+          r2 = r3
+        else
+          r2 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r2
+        if r2
+          if has_terminal?('=~', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('=~')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r6 = _nt_space
+            if r6
+              r5 = r6
+            else
+              r5 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s0 << r5
+            if r5
+              r7 = _nt_string
+              s0 << r7
+            end
+          end
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Approximately0)
+        r0.extend(Approximately1)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:approximately][start_index] = r0
+      r0
+    end
+    module NotEquals0
+      def field
+        elements[0]
+      end
+      def value
+        elements[4]
+      end
+    end
+    module NotEquals1
+      def sql
+        Sequel::SQL::BooleanExpression.from_value_pairs({field.sql => value.sql}, :AND, true)
+      end
+    end
+    def _nt_not_equals
+      start_index = index
+      if node_cache[:not_equals].has_key?(index)
+        cached = node_cache[:not_equals][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      r1 = _nt_field
+      s0 << r1
+      if r1
+        r3 = _nt_space
+        if r3
+          r2 = r3
+        else
+          r2 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r2
+        if r2
+          if has_terminal?('!=', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('!=')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r6 = _nt_space
+            if r6
+              r5 = r6
+            else
+              r5 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s0 << r5
+            if r5
+              r7 = _nt_value
+              s0 << r7
+            end
+          end
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(NotEquals0)
+        r0.extend(NotEquals1)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:not_equals][start_index] = r0
+      r0
+    end
+    module Equals0
+      def field
+        elements[0]
+      end
+      def value
+        elements[4]
+      end
+    end
+    module Equals1
+      def sql
+        Sequel::SQL::BooleanExpression.from_value_pairs field.sql => value.sql
+      end
+    end
+    def _nt_equals
+      start_index = index
+      if node_cache[:equals].has_key?(index)
+        cached = node_cache[:equals][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      r1 = _nt_field
+      s0 << r1
+      if r1
+        r3 = _nt_space
+        if r3
+          r2 = r3
+        else
+          r2 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r2
+        if r2
+          i4 = index
+          if has_terminal?('=', false, index)
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('=')
+            r5 = nil
+          end
+          if r5
+            r4 = r5
+          else
+            if has_terminal?('==', false, index)
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure('==')
+              r6 = nil
+            end
+            if r6
+              r4 = r6
+            else
+              @index = i4
+              r4 = nil
+            end
+          end
+          s0 << r4
+          if r4
+            r8 = _nt_space
+            if r8
+              r7 = r8
+            else
+              r7 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s0 << r7
+            if r7
+              r9 = _nt_value
+              s0 << r9
+            end
+          end
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Equals0)
+        r0.extend(Equals1)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:equals][start_index] = r0
+      r0
+    end
+    def _nt_value
+      start_index = index
+      if node_cache[:value].has_key?(index)
+        cached = node_cache[:value][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0 = index
+      r1 = _nt_double_quoted_string
+      if r1
+        r0 = r1
+      else
+        r2 = _nt_float
+        if r2
+          r0 = r2
+        else
+          r3 = _nt_integer
+          if r3
+            r0 = r3
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+      node_cache[:value][start_index] = r0
+      r0
+    end
+    module Integer0
+    end
+    module Integer1
+      def ruby_value
+        Integer(text_value)
+      end
+      alias sql ruby_value
+    end
+    def _nt_integer
+      start_index = index
+      if node_cache[:integer].has_key?(index)
+        cached = node_cache[:integer][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      if has_terminal?('-', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('-')
+        r2 = nil
+      end
+      if r2
+        r1 = r2
+      else
+        r1 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r1
+      if r1
+        s3, i3 = [], index
+        loop do
+          if has_terminal?('\G[0-9]', true, index)
+            r4 = true
+            @index += 1
+          else
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        if s3.empty?
+          @index = i3
+          r3 = nil
+        else
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        end
+        s0 << r3
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Integer0)
+        r0.extend(Integer1)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:integer][start_index] = r0
+      r0
+    end
+    module Float0
+    end
+    module Float1
+      def ruby_value
+        Float(text_value)
+      end
+      alias sql ruby_value
+    end
+    def _nt_float
+      start_index = index
+      if node_cache[:float].has_key?(index)
+        cached = node_cache[:float][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      if has_terminal?('-', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('-')
+        r2 = nil
+      end
+      if r2
+        r1 = r2
+      else
+        r1 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r1
+      if r1
+        s3, i3 = [], index
+        loop do
+          if has_terminal?('\G[0-9]', true, index)
+            r4 = true
+            @index += 1
+          else
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        if s3.empty?
+          @index = i3
+          r3 = nil
+        else
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        end
+        s0 << r3
+        if r3
+          if has_terminal?('.', false, index)
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('.')
+            r5 = nil
+          end
+          s0 << r5
+          if r5
+            s6, i6 = [], index
+            loop do
+              if has_terminal?('\G[0-9]', true, index)
+                r7 = true
+                @index += 1
+              else
+                r7 = nil
+              end
+              if r7
+                s6 << r7
+              else
+                break
+              end
+            end
+            if s6.empty?
+              @index = i6
+              r6 = nil
+            else
+              r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+            end
+            s0 << r6
+          end
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Float0)
+        r0.extend(Float1)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:float][start_index] = r0
+      r0
+    end
+    module Field0
+      def sql
+        text_value.to_sym
+      end
+    end
+    def _nt_field
+      start_index = index
+      if node_cache[:field].has_key?(index)
+        cached = node_cache[:field][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0 = index
+      if has_terminal?("state", false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
+        @index += 5
+      else
+        terminal_parse_failure("state")
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+        r0.extend(Field0)
+      else
+        if has_terminal?("host", false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
+          @index += 4
+        else
+          terminal_parse_failure("host")
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+          r0.extend(Field0)
+        else
+          if has_terminal?("service", false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 7))
+            @index += 7
+          else
+            terminal_parse_failure("service")
+            r3 = nil
+          end
+          if r3
+            r0 = r3
+            r0.extend(Field0)
+          else
+            if has_terminal?("description", false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 11))
+              @index += 11
+            else
+              terminal_parse_failure("description")
+              r4 = nil
+            end
+            if r4
+              r0 = r4
+              r0.extend(Field0)
+            else
+              if has_terminal?("metric_f", false, index)
+                r5 = instantiate_node(SyntaxNode,input, index...(index + 8))
+                @index += 8
+              else
+                terminal_parse_failure("metric_f")
+                r5 = nil
+              end
+              if r5
+                r0 = r5
+                r0.extend(Field0)
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+      node_cache[:field][start_index] = r0
+      r0
+    end
+    def _nt_string
+      start_index = index
+      if node_cache[:string].has_key?(index)
+        cached = node_cache[:string][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      r0 = _nt_double_quoted_string
+      node_cache[:string][start_index] = r0
+      r0
+    end
+    module DoubleQuotedString0
+    end
+    module DoubleQuotedString1
+    end
+    module DoubleQuotedString2
+      def ruby_value
+        text_value[1..-2].gsub('\"', '"')
+      end
+      alias sql ruby_value
+    end
+    def _nt_double_quoted_string
+      start_index = index
+      if node_cache[:double_quoted_string].has_key?(index)
+        cached = node_cache[:double_quoted_string][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      i0, s0 = index, []
+      if has_terminal?('"', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('"')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3 = index
+          i4, s4 = index, []
+          i5 = index
+          if has_terminal?('"', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('"')
+            r6 = nil
+          end
+          if r6
+            r5 = nil
+          else
+            @index = i5
+            r5 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s4 << r5
+          if r5
+            if index < input_length
+              r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r7 = nil
+            end
+            s4 << r7
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(DoubleQuotedString0)
+          else
+            @index = i4
+            r4 = nil
+          end
+          if r4
+            r3 = r4
+          else
+            if has_terminal?('\"', false, index)
+              r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure('\"')
+              r8 = nil
+            end
+            if r8
+              r3 = r8
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+        if r2
+          if has_terminal?('"', false, index)
+            r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('"')
+            r9 = nil
+          end
+          s0 << r9
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(DoubleQuotedString1)
+        r0.extend(DoubleQuotedString2)
+      else
+        @index = i0
+        r0 = nil
+      end
+      node_cache[:double_quoted_string][start_index] = r0
+      r0
+    end
+    def _nt_space
+      start_index = index
+      if node_cache[:space].has_key?(index)
+        cached = node_cache[:space][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+      s0, i0 = [], index
+      loop do
+        if has_terminal?('\G[\\s]', true, index)
+          r1 = true
+          @index += 1
+        else
+          r1 = nil
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      end
+      node_cache[:space][start_index] = r0
+      r0
+    end
+  end
+  class QueryStringParser < Treetop::Runtime::CompiledParser
+    include QueryString
+  end
+end