haproxy-tools 0.1.0 → 0.2.0

data/haproxy-tools.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{haproxy-tools}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jason Wadsworth"]
+  s.date = %q{2012-04-24}
+  s.description = %q{Ruby tools for HAProxy, including config file management.}
+  s.email = %q{jdwadsworth@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc",
+    "TODO"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "CHANGES.rdoc",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "docs/haproxy-1.3-configuration.txt",
+    "docs/haproxy-1.4-configuration.txt",
+    "haproxy-tools.gemspec",
+    "lib/haproxy-tools.rb",
+    "lib/haproxy/config.rb",
+    "lib/haproxy/parser.rb",
+    "lib/haproxy/renderer.rb",
+    "lib/haproxy/treetop/config.treetop",
+    "lib/haproxy/treetop/nodes.rb",
+    "lib/haproxy_tools.rb",
+    "spec/fixtures/multi-pool.haproxy.cfg",
+    "spec/fixtures/simple.haproxy.cfg",
+    "spec/haproxy/config_spec.rb",
+    "spec/haproxy/parser_spec.rb",
+    "spec/haproxy/treetop/config_parser_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/subakva/haproxy-tools}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{HAProxy Tools for Ruby}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<net-scp>, [">= 0"])
+      s.add_runtime_dependency(%q<orderedhash>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.7.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.7.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<treetop>, [">= 0"])
+    else
+      s.add_dependency(%q<net-scp>, [">= 0"])
+      s.add_dependency(%q<orderedhash>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.7.0"])
+      s.add_dependency(%q<yard>, ["~> 0.7.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<treetop>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<net-scp>, [">= 0"])
+    s.add_dependency(%q<orderedhash>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.7.0"])
+    s.add_dependency(%q<yard>, ["~> 0.7.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<treetop>, [">= 0"])
+  end
+end
+

data/lib/haproxy/config.rb

@@ -1,34 +1,71 @@
 module HAProxy
-  Backend   = Struct.new(:name, :servers)
-  Frontend  = Struct.new(:name, :ip, :port)
-  Server    = Struct.new(:name, :ip, :port, :options)
+  Default   = Struct.new(:name, :options, :config)
+  Backend   = Struct.new(:name, :options, :config, :servers)
+  Listener  = Struct.new(:name, :host, :port, :options, :config, :servers)
+  Frontend  = Struct.new(:name, :host, :port, :options, :config)
+  Server    = Struct.new(:name, :host, :port, :attributes)
 
-  class Config
-    attr_accessor :options, :backends, :frontends, :option_groups
-    
-    def initialize(options = nil)
-      self.options = options || {}
-      self.backends = []
-      self.frontends = []
-      self.option_groups = {'global' => {}, 'defaults' => {}}
+  module ServerList
+    def add_server(name, host, options)
+      options ||= {}
+      new_server = options[:template] ? options[:template].clone : Server.new
+      new_server.name       = name
+      new_server.host       = host
+      new_server.port       = options[:port] if options[:port]
+      new_server.attributes ||= options[:attributes] || []
+      self.servers[name] = new_server
+      new_server
     end
+  end
+
+  class Listener
+    include ServerList
+  end
 
-    def global
-      option_groups['global']
+  class Backend
+    include ServerList
+  end
+
+  class Config
+    attr_accessor :original_parse_tree, :listeners, :backends, :frontends, :global, :defaults
+    
+    def initialize(parse_tree)
+      self.original_parse_tree = parse_tree
+      self.backends   = []
+      self.listeners  = []
+      self.frontends  = []
+      self.defaults   = []
+      self.global     = {}
     end
 
-    def defaults
-      option_groups['defaults']
+    def listener(name)
+      self.listeners.find { |l| l.name == name }
     end
 
     def backend(name)
       self.backends.find { |b| b.name == name }
     end
 
+    def frontend(name)
+      self.frontends.find { |f| f.name == name }
+    end
+
+    def default(name)
+      self.defaults.find { |d| d.name == name }
+    end
+
+    def render
+      renderer = HAProxy::Renderer.new(self, self.original_parse_tree)
+      renderer.render
+    end
+
+    protected
+
     class << self
-      def parse(filename)
-        HAProxy::Parser.new.parse(filename)
+      def parse_file(filename)
+        HAProxy::Parser.new.parse_file(filename)
       end
     end
   end
 end
+

data/lib/haproxy/parser.rb

@@ -1,7 +1,16 @@
 module HAProxy
 	class Parser
-    attr_accessor :verbose, :options
-    attr_accessor :current_backend, :current_section, :current_frontend, :current_section_name
+    class Error < Exception; end
+
+    # haproxy 1.3
+    SERVER_ATTRIBUTE_NAMES = %w{
+      addr backup check cookie disabled fall id inter fastinter downinter
+      maxconn maxqueue minconn port redir rise slowstart source track weight
+    }
+    # Added in haproxy 1.4
+    SERVER_ATTRIBUTE_NAMES += %w{error-limit observe on-error}
+
+    attr_accessor :verbose, :options, :parse_result
 
     def initialize(options = nil)
       options ||= {}
@@ -9,92 +18,133 @@ module HAProxy
 
       self.options = options
       self.verbose = options[:verbose]
-      reset_parser_flags
     end
 
-    def reset_parser_flags
-      self.current_section   = nil
-      self.current_backend   = nil
-      self.current_frontend  = nil
+    def parse_file(filename)
+      config_text = File.read(filename)
+      self.parse(config_text)
     end
 
-    # This is starting to suck. Try treetop.
-    def parse(filename)
-      self.reset_parser_flags
-
-      config = HAProxy::Config.new
-      start_backend(config, 'default')
-      start_frontend(config, 'default')
-
-      lines = File.readlines(filename)
-      lines.each do |line|
-        line.strip!
-        case line.strip
-        when /^(global|defaults)$/
-          start_section(config, $1)
-        when /^frontend\W+([^\W]+)\W+([^\W:]+):(\d+)/
-          start_section(config, 'frontend')
-          start_frontend(config, $1)
-        when /^backend\W+([^\W]+)/
-          start_section(config, 'backend')
-          start_backend(config, $1)
-        when /^server\W+([^\W]+)\W+([\d\.]+):(\d+)(.*)/
-          append_server($1, $2, $3, $4)
-        when /^([^\W]+)([^#]*)/ # match other name/value pairs; ignore comments
-          append_option($1, $2)
-        when /^$/
-        when /^#.*/
-          puts " => Ignoring comment: #{line}" if verbose
-        else
-          puts " => Skipping non-matching line: #{line}" if verbose
-        end
+    def parse(config_text)
+      parser = HAProxy::Treetop::ConfigParser.new
+      result = parser.parse(config_text)
+      raise HAProxy::Parser::Error.new(parser.failure_reason) if result.nil?
+
+      config = HAProxy::Config.new(result)
+      config.global = config_hash_from_config_section(result.global)
+
+      result.frontends.each do |fs|
+        f = Frontend.new
+        f.name        = try(fs.frontend_header, :proxy_name, :content)
+        f.host        = try(fs.frontend_header, :service_address, :host, :content)
+        f.port        = try(fs.frontend_header, :service_address, :port, :content)
+        f.options     = options_hash_from_config_section(fs)
+        f.config      = config_hash_from_config_section(fs)
+        config.frontends << f
       end
 
-      config
-    end
-
-    def normalize_option_string(option_string)
-      normalized_options = option_string.strip.split
-      normalized_options = normalized_options.first if normalized_options.size <= 1
-      normalized_options
-    end
+      result.backends.each do |bs|
+        b = Backend.new
+        b.name        = try(bs.backend_header, :proxy_name, :content)
+        b.options     = options_hash_from_config_section(bs)
+        b.config      = config_hash_from_config_section(bs)
+        b.servers     = server_hash_from_config_section(bs)
+        config.backends << b
+      end
 
-    def append_option(name, option_string)
-      normalized_options = normalize_option_string(option_string)
+      result.listeners.each do |ls|
+        l = Listener.new
+        l.name        = try(ls.listen_header, :proxy_name, :content)
+        l.host        = try(ls.listen_header, :service_address, :host, :content)
+        l.port        = try(ls.listen_header, :service_address, :port, :content)
+        l.options     = options_hash_from_config_section(ls)
+        l.config      = config_hash_from_config_section(ls)
+        l.servers     = server_hash_from_config_section(ls)
+        config.listeners << l
+      end
 
-      puts " => Adding #{current_section_name} option : #{name} = #{normalized_options.inspect}" if verbose
+      result.defaults.each do |ds|
+        d = Default.new
+        d.name        = try(ds.defaults_header, :proxy_name, :content)
+        d.options     = options_hash_from_config_section(ds)
+        d.config      = config_hash_from_config_section(ds)
+        config.defaults << d
+      end
 
-      current_section[name] ||= []
-      self.current_section[name] << normalized_options unless normalized_options.nil?
+      self.parse_result = result
+      config
     end
 
-    def append_server(name, ip, port, option_string)
-      puts " => Adding server: #{name}" if verbose
+    protected
 
-      server_options = normalize_option_string(option_string)
-      self.current_backend.servers[name] = Server.new(name, ip, port, server_options)
+    def try(node, *method_names)
+      method_name = method_names.shift
+      if node.respond_to?(method_name)
+        next_node = node.send(method_name)
+        method_names.empty? ? next_node : try(next_node, *method_names)
+      else
+        nil
+      end
     end
 
-    def start_section(config, name)
-      puts " => Starting option_group: #{name}" if verbose
-
-      config.option_groups[name] ||= {}
-      self.current_section_name = name
-      self.current_section = config.option_groups[name]
+    def server_hash_from_config_section(cs)
+      cs.servers.inject({}) do |ch, s|
+        value = try(s, :value, :content)
+        ch[s.name] = Server.new(s.name, s.host, s.port, parse_server_attributes(value))
+        ch
+      end
     end
 
-    def start_frontend(config, name)
-      puts " => Starting frontend: #{name}" if verbose
+    # Parses server attributes from the server value. I couldn't get manage to get treetop to do this.
+    # 
+    # Types of server attributes to support:
+    # ipv4, boolean, string, integer, time (us, ms, s, m, h, d), url, source attributes
+    # 
+    # BUG: If an attribute value matches an attribute name, the parser will assume that a new attribute value
+    # has started. I don't know how haproxy itself handles that situation.
+    def parse_server_attributes(value)
+      parts = value.split(/\s/)
+      current_name = nil
+      pairs = parts.inject(OrderedHash.new) do |pairs, part|
+        if SERVER_ATTRIBUTE_NAMES.include?(part)
+          current_name  = part
+          pairs[current_name] = []
+        elsif current_name.nil?
+          raise "Invalid server attribute: #{part}"
+        else
+          pairs[current_name] << part
+        end
+        pairs
+      end
 
-      self.current_frontend = Frontend.new(name, {})
-      config.frontends << self.current_frontend
+      return clean_parsed_server_attributes(pairs)
+    end
+
+    # Converts attributes with no values to true, and combines everything else into space-separated strings.
+    def clean_parsed_server_attributes(pairs)
+      pairs.each do |k,v|
+        if v.empty?
+          pairs[k] = true
+        else
+          pairs[k] = v.join(' ')
+        end
+      end
     end
 
-    def start_backend(config, name)
-      puts " => Starting backend: #{name}" if verbose
+    def options_hash_from_config_section(cs)
+      cs.option_lines.inject({}) do |ch, l|
+        ch[l.keyword.content] = l.value ? l.value.content : nil
+        ch
+      end
+    end
 
-      self.current_backend = Backend.new(name, {})
-      config.backends << self.current_backend
+    def config_hash_from_config_section(cs)
+      cs.config_lines.reject{|l| l.keyword.content == 'option'}.inject({}) do |ch, l|
+        ch[l.keyword.content] = l.value ? l.value.content : nil
+        ch
+      end
     end
-	end
+
+  end
 end
+

data/lib/haproxy/renderer.rb

@@ -0,0 +1,111 @@
+module HAProxy
+  class Renderer
+
+    attr_accessor :config, :source_tree
+
+    def initialize(config, source_tree)
+      self.config       = config
+      self.source_tree  = source_tree
+      @server_list      = {}
+      @context          = self.config
+      @prev_context     = self.config
+      @config_text      = ''
+    end
+
+    def render
+      render_node(self.source_tree)
+      handle_context_change
+      @config_text
+    end
+
+    def render_node(node)
+      node.elements.each do |e|
+        update_render_context(e)
+
+        handle_context_change if context_changed?
+
+        if e.class == HAProxy::Treetop::ServerLine
+          # Keep track of the servers that we've seen, so that we can detect and render new ones.
+          @server_list[e.name] = e
+          # Don't render the server element if it's been deleted from the config.
+          next if @context.servers[e.name].nil?
+        end
+
+        if e.class == HAProxy::Treetop::ServerLine
+          # Use a custom rendering method for servers, since we allow them to be added/removed/changed.
+          render_server_element(e)
+        elsif e.elements && e.elements.size > 0
+          render_node(e)
+        else
+          @config_text << e.text_value
+        end
+      end
+      @config_text
+    end
+
+    protected
+
+    def context_changed?
+      @context != @prev_context
+    end
+
+    def render_server_element(e)
+      server = @context.servers[e.name]
+      render_server(server)
+    end
+
+    def render_server(server)
+      attribute_string = render_server_attributes(server.attributes)
+      @config_text << "\tserver #{server.name} #{server.host}:#{server.port} #{attribute_string}\n"
+    end
+
+    def handle_context_change
+      if [HAProxy::Listener, HAProxy::Backend].include?(@prev_context.class)
+        # Render any servers that were added
+        new_servers = @prev_context.servers.keys - @server_list.keys
+
+        new_servers.each do |server_name|
+          server = @prev_context.servers[server_name]
+          render_server(server)
+        end
+      end
+      @server_list = {}
+    end
+
+    def render_server_attributes(attributes)
+      attribute_string = ""
+      attributes.each do |name, value|
+        attribute_string << name
+        attribute_string << " "
+        if value && value != true
+          attribute_string << value
+          attribute_string << " "
+        end
+      end
+      attribute_string
+    end
+
+    def update_render_context(e)
+      @prev_context = @context
+      case e.class.name
+      when 'HAProxy::Treetop::GlobalSection'
+        @context = @config.global
+      when 'HAProxy::Treetop::DefaultsSection'
+        section_name = e.defaults_header.proxy_name ? e.defaults_header.proxy_name.content : nil
+        @context = @config.default(section_name)
+      when 'HAProxy::Treetop::ListenSection'
+        section_name = e.listen_header.proxy_name ? e.listen_header.proxy_name.content : nil
+        @context = @config.listener(section_name)
+      when 'HAProxy::Treetop::FrontendSection'
+        section_name = e.frontend_header.proxy_name ? e.frontend_header.proxy_name.content : nil
+        @context = @config.frontend(section_name)
+      when 'HAProxy::Treetop::BackendSection'
+        section_name = e.backend_header.proxy_name ? e.backend_header.proxy_name.content : nil
+        @context = @config.backend(section_name)
+      else
+        @context = @prev_context
+      end
+    end
+  end
+end
+