nagios_config 0.0.1

data/README.rdoc

@@ -0,0 +1,39 @@
+= NagiosConfig
+
+NagiosConfig provides tools to parse, manipulate, generate and output Nagios configuration files using Ruby.
+
+== NagiosConfig::Parser
+
+NagiosConfig::Parser will parse both the object and main style Nagios configuration files, and has both a streaming API and the ability to produce a AST/DOM-like structure.
+
+== NagiosConfig::Builder
+
+NagiosConfig::Builder is a simple DSL for generating Nagios config files using Ruby
+
+== NagiosConfig::Formater
+
+NagiosConfig::Formater will take the data structures produced by the parser and builder and output them in the format of a Nagios config file.
+
+== Making changes to a config file
+
+Say for example you decided you want all your host names uppercase
+
+  require 'rubygems'
+  require 'nagios_config'
+  
+  host_config = nil
+  File.open("hosts.cfg") do |f|
+    host_config = NagiosConfig::Parser.new.parse(f)
+  end
+  
+  host_config.defines do |node|
+    if node.type.value == "host"
+      variable = node.variables.find {|node| node.name.value == "hostname"}
+      variable.val.value.upcase! if variable
+    end
+  end
+  
+  File.open("hosts.cfg", "w") do |f|
+    NagiosConfig::Formatter.new(f).format(host_config)
+  end
+

data/lib/nagios_config.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + "/nagios_config/errors"
+require File.dirname(__FILE__) + "/nagios_config/node"
+require File.dirname(__FILE__) + "/nagios_config/ast"
+require File.dirname(__FILE__) + "/nagios_config/parser"
+require File.dirname(__FILE__) + "/nagios_config/formater"
+require File.dirname(__FILE__) + "/nagios_config/builder"
+require File.dirname(__FILE__) + "/nagios_config/object"

data/lib/nagios_config/ast.rb

@@ -0,0 +1,42 @@
+module NagiosConfig
+  
+  class TrailingComment < Node
+  end
+  
+  class Whitespace < Node
+    node :trailing_comment, NagiosConfig::TrailingComment
+  end
+  
+  class Comment < Node
+  end
+  
+  class Type < Node
+  end
+  
+  class Name < Node
+  end
+  
+  class Value < Node
+  end
+  
+  class Variable < Node
+    node :name, NagiosConfig::Name
+    node :val, NagiosConfig::Value
+    node :trailing_comment, NagiosConfig::TrailingComment
+  end
+  
+  class Define < Node
+    node :type, NagiosConfig::Type
+    node :comment, NagiosConfig::Comment
+    node :trailing_comment, NagiosConfig::TrailingComment
+    nodes :whitespace, NagiosConfig::Whitespace
+    nodes :variables, NagiosConfig::Variable
+  end
+  
+  class Config < Node
+    node :comment, NagiosConfig::Comment
+    nodes :whitespace, NagiosConfig::Whitespace
+    nodes :variables, NagiosConfig::Variable
+    nodes :defines, NagiosConfig::Define
+  end
+end

data/lib/nagios_config/builder.rb

@@ -0,0 +1,100 @@
+module NagiosConfig
+  
+  # Usage:
+  #   conf = NagiosConfig::Builder.new
+  #   
+  #   conf.foo = "bar"
+  #   conf.define("test") do |test|
+  #     test.a = "b"
+  #     test.a.comment("foo")
+  #   end
+  #   
+  #   puts conf
+  class Builder
+    attr_accessor :root
+    
+    def initialize(root=NagiosConfig::Config.new)
+      self.root = root
+    end
+    
+    def [](name)
+      var = get_variable_named(name)
+      if var
+        extend(var.val.value, var)
+      end
+    end
+    
+    def []=(name, value)
+      set_variable_named(name, value)
+      value
+    end
+    
+    def define(type)
+      raise "can't define in a define" if root.is_a?(NagiosConfig::Define)
+      define = NagiosConfig::Define.new
+      define.add_node(NagiosConfig::Type.new(type.to_s))
+      root.add_node(define)
+      yield self.class.new(define)
+      define
+    end
+    
+    def break
+      root.add_node(NagiosConfig::Whitespace.new("\n"))
+    end
+    
+    def comment(string)
+      root.add_node(NagiosConfig::Comment.new(string))
+    end
+    
+    def to_s
+      NagiosConfig::Formater.new.format(root)
+    end
+    
+    def method_missing(name, *args)
+      if name.to_s =~ /=$/ && args.length == 1
+        self[name.to_s.chomp("=")] = args.first
+      elsif args.empty?
+        self[name]
+      else
+        super
+      end
+    end
+    
+    private
+    def get_variable_named(name)
+      root.nodes.find do |node|
+        node.is_a?(NagiosConfig::Variable) && node.name.value == name.to_s
+      end
+    end
+    
+    def set_variable_named(name, value)
+      var = get_variable_named(name)
+      if !var && !value.nil?
+        var = NagiosConfig::Variable.new
+        var.add_node(NagiosConfig::Name.new(name))
+        var.add_node(NagiosConfig::Value.new)
+        root.add_node(var)
+      end
+      if value.nil?
+        root.remove_node(var)
+      elsif value == true
+        var.val.value = "1"
+      elsif value == false
+        var.val.value = "0"
+      else
+        var.val.value = value.to_s
+      end
+      var
+    end
+    
+    def extend(value, parent)
+      metaclass = class << value; self; end
+      metaclass.send(:define_method, :comment) do |string|
+        parent.add_node(NagiosConfig::TrailingComment.new(string))
+      end
+      value
+    end
+    
+    
+  end
+end

data/lib/nagios_config/errors.rb

@@ -0,0 +1,4 @@
+module NagiosConfig
+  class ParseError < RuntimeError; end
+  class ParentNotFound < RuntimeError; end
+end

data/lib/nagios_config/formater.rb

@@ -0,0 +1,72 @@
+module NagiosConfig
+  class Formater
+    attr_accessor :buffer, :in_define, :define_indent, :define_name_width, :define_variable_width
+    
+    def initialize(buffer="")
+      self.buffer = buffer
+      self.define_indent = 2
+      self.define_name_width = 2
+      self.define_variable_width = 2
+    end
+    
+    def format(root)
+      root.nodes.each do |node|
+        op = "format_#{node.class.name.sub(/^NagiosConfig::/, "").gsub(/::/, "_")}"
+        send(op, node)
+      end
+      buffer
+    end
+    alias format_Config format
+    
+    def format_Comment(comment)
+      if comment.value.empty?
+        buffer << "#\n"
+      else
+        buffer << comment.value.split(/\n/).map do |comment|
+          "##{comment}\n"
+        end.join
+      end
+    end
+    
+    def format_Whitespace(whitespace)
+      buffer << whitespace.value
+    end
+    
+    def format_Variable(variable)
+      if in_define
+        format = "#{" " * define_indent}%-#{define_name_width}s%s"
+      else
+        format = "%s=%s"
+      end
+      var_string = format % [variable.name.value, variable.val.value]
+      if variable.trailing_comment
+        var_string = "%-#{define_variable_width}s;%s" % [var_string, variable.trailing_comment.value]
+      end
+      buffer << var_string << "\n"
+    end
+    
+    def format_Define(define)
+      buffer << "define "
+      name_width = define.variables.map(&:name).map(&:value).map(&:length).max || 0
+      value_width = define.variables.map(&:val).map(&:value).map(&:length).max || 0
+      variable_width = define_indent + define_name_width + name_width + value_width
+      
+      self.define_name_width += name_width
+      self.define_variable_width += variable_width
+      self.in_define = true
+      
+      format(define)
+      
+      self.in_define = false
+      self.define_variable_width -= variable_width
+      self.define_name_width -= name_width
+      
+      buffer << "}\n"
+    end
+    
+    def format_Type(type)
+      buffer << "#{type.value} {\n"
+    end
+    
+  end
+end

data/lib/nagios_config/node.rb

@@ -0,0 +1,74 @@
+module NagiosConfig
+  class Node
+    attr_accessor :nodes, :value
+    
+    def initialize(value=nil)
+      self.value = value
+      self.nodes = []
+    end
+    
+    def self.allow(*node_types)
+      if node_types.any?
+        allow.push(*node_types)
+      else
+        @allowed_node_types ||= []
+      end
+    end
+    
+    def self.nodes(name, klass, singular=name.to_s.chomp("s"))
+      define_method(name) do
+        nodes.select {|n| n.is_a?(klass)}
+      end
+      alias_method :"add_#{singular}", :add_node
+      allow(klass)
+      yield klass if block_given?
+    end
+    
+    def self.node(name, klass=generate_node_type(name))
+      define_method(name) do
+        nodes.find {|n| n.is_a?(klass)}
+      end
+      define_method("#{name}=") do |value|
+        remove_node(name)
+        add_node(value) if value
+      end
+      allow(klass)
+      yield klass if block_given?
+    end
+    
+    def allow?(node)
+      self.class.allow.include?(node.class)
+    end
+    
+    def add_node(node)
+      raise "node type #{node.class} not allowed in #{self.class}" unless allow?(node)
+      nodes << node
+      self
+    end
+    
+    def remove_node(node)
+      nodes.delete(node)
+      self
+    end
+    
+    def after(node)
+      nodes[nodes.index(node) + 1]
+    end
+    
+    def before(node)
+      index = nodes.index(node) - 1
+      if index >= 0
+        nodes[index]
+      end
+    end
+    
+    def insert_before(position_node, node)
+      nodes.insert(nodes.index(position_node), node)
+    end
+    
+    def insert_after(position_node, node)
+      nodes.insert(nodes.index(position_node) + 1, node)
+    end
+    
+  end
+end

data/lib/nagios_config/object.rb

@@ -0,0 +1,115 @@
+module NagiosConfig
+  class Object
+    @@all = []
+    @@template_cache = {}
+    attr_accessor :type, :own_variables, :objectspace, :parent
+    
+    def initialize(type, variables={}, objectspace=@@all)
+      self.type = type.to_sym
+      self.own_variables = Hash[variables.map {|k,v| [k.to_sym,v]}]
+      self.objectspace = objectspace
+    end
+    
+    def self.from_node(node, objectspace=@@all)
+      instance = new(node.type.value, {}, objectspace)
+      node.variables.each do |variable|
+        instance[variable.name.value] = variable.val.value
+      end
+      instance
+    end
+    
+    def self.find_template(type, name, objectspace=@@all)
+      type = type.to_sym
+      name = name.to_s
+      key = [type, name, objectspace.object_id]
+      cached = @@template_cache[key]
+      
+      if cached && cached.type == type && cached.name == name
+        cached
+      else
+        @@template_cache[key] = objectspace.find do |obj|
+          obj.type == type && obj.name == name
+        end
+      end
+    end
+    
+    def self.clear_cache
+      @@template_cache.clear
+    end
+    
+    def self.clear
+      objectspace.clear
+      clear_cache
+      nil
+    end
+    
+    def self.objectspace
+      @@all
+    end
+    
+    def parent
+      use = own_variables[:use]
+      if use
+        parent = self.class.find_template(type, use, objectspace)
+        raise ParentNotFound.new("can't use #{use}") unless parent
+        parent
+      end
+    end
+    
+    def [](name)
+      name = name.to_sym
+      result = own_variables[name]
+      if result
+        result
+      elsif own_variables[:use] && name != :name && name != :register
+        parent[name]
+      end
+    end
+    
+    def []=(name, value)
+      own_variables[name.to_sym] = value
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && other.type == type &&
+        other.variables == variables
+    end
+    
+    def objectspace=(value)
+      @objectspace.delete(self) if @objectspace
+      value.push(self) if value
+      @objectspace = value
+    end
+    
+    def inspect
+      "#<#{self.class.name}:#{object_id} @type=#{type}, " <<
+      "@objectspace=#{objectspace.class.name}:#{objectspace.object_id}" <<
+      "(#{objectspace.length} items), @own_variables=#{own_variables.inspect}>"
+    end
+    
+    def method_missing(name, *args)
+      if name.to_s !~ /=$/ && args.empty?
+        self[name.to_sym]
+      elsif name.to_s =~ /=$/ && args.length == 1
+        self[name.to_s.chomp("=").to_sym] = args.first
+      else
+        super
+      end
+    end
+    
+    protected
+    def variables
+      parent_variables = parent.variables if parent
+      if parent_variables
+        parent_variables.delete(:name)
+        parent_variables.delete(:register)
+        variables = parent_variables.merge(own_variables)
+        variables.delete(:use)
+        variables
+      else
+        own_variables.dup
+      end
+    end
+    
+  end
+end

data/lib/nagios_config/parser.rb

@@ -0,0 +1,218 @@
+require 'strscan'
+require 'stringio'
+require 'rubygems'
+require 'events'
+
+module NagiosConfig
+  class Parser
+    attr_accessor :scanner, :state, :in_define, :value_buffer
+    include Events::Emitter
+    
+    def initialize
+      @state = :body
+      self.scanner = StringScanner.new("")
+      self.value_buffer = ""
+    end
+    
+    def parse(io)
+      root = NagiosConfig::Config.new
+      current_define = nil
+      current_variable = nil
+      on(:comment) do |comment|
+        (current_define || root).add_node(NagiosConfig::Comment.new(comment))
+      end
+      on(:whitespace) do |whitespace|
+        (current_define || root).add_node(NagiosConfig::Whitespace.new(whitespace))
+      end
+      on(:trailing_comment) do |comment|
+        (current_define || root).nodes.last.add_node(NagiosConfig::TrailingComment.new(comment))
+      end
+      on(:name) do |name|
+        current_variable = NagiosConfig::Variable.new
+        current_variable.add_node(NagiosConfig::Name.new(name))
+        (current_define || root).add_node(current_variable)
+      end
+      on(:value) do |value|
+        current_variable.add_node(NagiosConfig::Value.new(value))
+        current_variable = nil
+      end
+      on(:begin_define) do
+        current_define = NagiosConfig::Define.new
+        root.add_node(current_define)
+      end
+      on(:type) do |type|
+        current_define.add_node(NagiosConfig::Type.new(type))
+      end
+      on(:finish_define) do
+        current_define = nil
+      end
+      stream_parse(io)
+      root
+    end
+    
+    def stream_parse(io)
+      io = StringIO.new(io) unless io.respond_to?(:read)
+      until io.eof?
+        self << io.read(1024)
+      end
+    end
+    
+    def <<(string)
+      scanner.string.replace(scanner.rest)
+      scanner.reset
+      scanner << string
+      self.state = send(state)
+    end
+    
+    private
+    def body
+      empty_line || leading_whitespace || comment || definition || name || :body
+    end
+    alias start body
+    
+    def empty_line
+      whitespace = scanner.scan(/[ \t]*\n/)
+      if whitespace
+        emit(:whitespace, whitespace)
+        in_define ? definition_body : body
+      elsif in_define && whitespace = scanner.scan(/[ \t]*(?=;)/) && trailing_comment
+        emit(:whitespace, whitespace)
+        definition_body
+      end
+    end
+    
+    def leading_whitespace
+      if scanner.scan(/[ \t]+[^\s]/)
+        raise ParseError.new("leading whitespace not allowed")
+      end
+    end
+    
+    def comment
+      comment = scanner.scan(/[ \t]*#.*(\n)/)
+      if comment
+        comment.lstrip!
+        comment.slice!(0)
+        comment.chomp!("\n")
+        emit(:comment, comment)
+        in_define ? definition_body : body
+      elsif scanner.check(/#/)
+        :comment
+      end
+    end
+    
+    def name
+      name = scanner.scan(/[^\s=]+=/)
+      if name
+        name.chomp!("=")
+        emit(:name, name)
+        value
+      elsif scanner.scan(/.+\n/)
+        raise ParseError.new("expected variable definition")
+      elsif scanner.check(/[^\s]+/) && !scanner.check(/d(e(f(i(n(e?))?)?)?)?\Z/)
+        :name
+      end
+    end
+    
+    def value
+      value = scanner.scan(/.*\n/)
+      if value
+        value = value_buffer + value
+        value.chomp!("\n")
+        raise ParseError.new("value expected") if value.empty?
+        emit(:value, value)
+        self.value_buffer = ""
+        body
+      elsif value = scanner.scan(/.+/)
+        value_buffer << value
+        :value
+      else
+        :value
+      end
+    end
+    
+    def definition
+      if scanner.skip(/define[ \t]/)
+        emit(:begin_define)
+        self.in_define = true
+        type
+      end
+    end
+    
+    def type
+      type = scanner.scan(/[^;{]+[ \t]*\{[ \t]*\n/)
+      if type
+        type.strip!
+        type.chomp!("{")
+        type.strip!
+        emit(:type, type)
+        definition_body
+      elsif scanner.check(/([^;{]+[ \t]*(\{[ \t]*)?)?\Z/)
+        :type
+      else
+        raise ParseError.new("type expected")
+      end
+    end
+    
+    def definition_body
+      finish_definition || empty_line || comment || definition_name || :definition_body
+    end
+    
+    def definition_name
+      name = scanner.scan(/[ \t]*[^\s;#]+[ \t]+/)
+      if name
+        name.strip!
+        emit(:name, name)
+        definition_value
+      elsif scanner.check(/[ \t]*[^\s#;}]+\Z/)
+        :definition_name
+      elsif scanner.scan(/[ \t]*[^\s#;]+\n/)
+        raise ParseError.new("value expected")
+      end
+    end
+    
+    def definition_value
+      value = scanner.scan(/[^\n;#]*(?=(\n|;))/)
+      if value
+        value = value_buffer + value
+        value.strip!
+        raise ParseError.new("value expected") if value.empty?
+        emit(:value, value)
+        self.value_buffer = ""
+        after_value
+      elsif value = scanner.scan(/[^\n;#]+/)
+        value_buffer << value
+        :definition_value
+      else
+        :definition_value
+      end
+    end
+    
+    def after_value
+      if scanner.skip(/[ \t]*\n/) || trailing_comment
+        definition_body
+      else
+        :after_value
+      end
+    end
+    
+    def finish_definition
+      if scanner.scan(/[ \t]*\}[ \t]*\n/)
+        emit(:finish_define)
+        self.in_define = false
+        body
+      end
+    end
+    
+    def trailing_comment
+      trailing_comment = scanner.scan(/[ \t]*;.*\n/)
+      if trailing_comment
+        trailing_comment.strip!
+        trailing_comment.chomp!("\n")
+        trailing_comment.slice!(0)
+        emit(:trailing_comment, trailing_comment)
+      end
+      trailing_comment
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: nagios_config
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Matthew Sadler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-31 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: events
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  type: :runtime
+  version_requirements: *id001
+description: Read and write Nagios config files from Ruby
+email: mat@sourcetagsandcodes.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/nagios_config/ast.rb
+- lib/nagios_config/builder.rb
+- lib/nagios_config/errors.rb
+- lib/nagios_config/formater.rb
+- lib/nagios_config/node.rb
+- lib/nagios_config/object.rb
+- lib/nagios_config/parser.rb
+- lib/nagios_config.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/matsadler/nagios_config
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset
+- utf-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Nagios config parser and friends
+test_files: []
+