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

ustate-client 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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