proxymgr 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a0b2127ca7a38ef6934602e2a632610fb7c76c64
+  data.tar.gz: 13bb5a32815c235559e914658dcae62ea2ce7525
+SHA512:
+  metadata.gz: 253178319eab3516345259574e70f891bc735a765c82780b6603405b954738a7368ac0c54dacf9bb02a0c30200c1f312e2b5444dfaf1f5cd5465a50dc03df812
+  data.tar.gz: 4792f403f75f1110b8d87ff8f83172e32378352625d392f123da5c8d8e999982d4e900cf1c530241ca6a357dca80017a1d863e0be0963b793a91623685173232

data/.gitignore

@@ -0,0 +1,8 @@
+Dockerfile
+*.swp
+examples/dev.yml
+examples/docker.yml
+coverage/
+packaging/pkg*
+packaging/tmp*
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rubocop.yml

@@ -0,0 +1,11 @@
+Style/Documentation:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Enabled: false
+
+Lint/RescueException:
+  Enabled: false
+
+Style/HashSyntax:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org/"
+
+gemspec
+
+group :test do
+  gem 'simplecov', :require => false
+  gem 'coveralls', :require => false
+end

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    proxymgr (0.1)
+      absolute_time
+      docopt (~> 0.5.0)
+      state_machine
+      yajl-ruby
+      zookeeper
+      zoology
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    absolute_time (1.0.0)
+    coveralls (0.7.0)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    docile (1.1.5)
+    docopt (0.5.0)
+    mime-types (2.3)
+    multi_json (1.10.0)
+    netrc (0.7.7)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    simplecov (0.9.0)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    state_machine (1.2.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.3.0)
+    yajl-ruby (1.2.1)
+    zookeeper (1.4.8)
+    zoology (0.1)
+      state_machine
+      zookeeper
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls
+  proxymgr!
+  simplecov

data/README.md

@@ -0,0 +1,99 @@
+# ProxyMgr
+
+ProxyMgr manages Haproxy configuration dynamically. It was built to facilitate communication between services
+in cloud/dynamic environments where hosts providing a particular service may change frequently. DNS is typically
+not an option in these environments as most clients will cache resolution of hostnames indefinitely. Other service
+discovery solutions require integration in your applications, greatly increasing difficulty in adoption.
+
+ProxyMgr attempts to solve these issues by implementing dynamic reconfiguration of Haproxy. It retrieves service configuration
+data from Zookeeper and rewrites haproxy.cfg, as well as updating the state of the running process. It avoids reloading
+the process wherever possible and takes care not to drop connections when a reload is needed.
+
+## How it works
+
+ProxyMgr discovers configuration for services (Haproxy frontends/backends) by querying a `service_config` instance. The retrieved
+configuration is then used to set up a number of `watchers`, which are responsible for finding hosts that make up a service. Current
+watcher implementations support retrieving service hosts from Zookeeper, DNS, flat files, etc.
+
+## Installation
+
+ProxyMgr is available from Rubygems:
+
+```shell
+$ gem install proxymgr
+```
+
+## Getting started
+
+ProxyMgr has a configuration file which is used for configuring which service_config to use, as well as defaults for Haproxy. To configure
+ProxyMgr to retrieve service configuration from Zookeeper you could put this in `proxymgr.yml`:
+
+```yaml
+---
+haproxy:
+  config_path: /etc/haproxy/haproxy.cfg
+  socket_path: /var/run/haproxy/stats.sock
+
+service_config:
+  type: zookeeper
+  servers: localhost:2181
+  path: /service_config
+```
+
+ProxyMgr would then expect to find nodes in /service_config, where the name of the node would be the name of the listen section in Haproxy
+and the data would contain a JSON blob configuring the watcher for that particular service. The blob could look like this if you would want the
+watcher to retrieve hosts from Zookeeper:
+
+```json
+{"type": "zookeeper",
+ "server": "localhost:2181",
+ "path": "/services/testservice",
+ "listen_options": ["mode http"],
+ "server_options": ["check inter 2000"]}
+```
+
+ProxyMgr will now attempt to find nodes describing each server in /services/testservice. Each node should contain a blob looking like this:
+
+```json
+{"address": "1.2.3.4",
+ "port": 8080}
+```
+
+## Configuration
+
+ProxyMgr has a main configuration file, `proxymgr.yml`, which is used to configure which service_config to use as well as
+certain Haproxy options. Each section is a hash of configuration values.
+
+### `haproxy` section ###
+
+This section accepts a number of configuration options:
+
+* `global` should be an array of strings, where each element is a line which will appear in the global section of the Haproxy configuration.
+* `socket_path` is the path to where the Haproxy stats socket is to be located. ProxyMgr will not be able to enable and disable backends without restarting if this is not supplied.
+* `path` is the path to the Haproxy binary.
+
+### `service_config` section ###
+
+* `type` is the service_config type to use. "zookeeper" is currently the only available option.
+
+Each service_config has its own configuration keys/values, which should also be put in this section.
+
+#### `zookeeper` service_config ####
+
+* `servers` is a list of servers (in format of host:port) separated by commas that should be used to find service configuration
+* `path` is a path where service configuration nodes can be found.
+
+## Haproxy management
+
+ProxyMgr manages the Haproxy process directly; it does not rely on external process managers. This also enables ProxyMgr to provide seamless
+reloads by opening listen sockets and passing them to Haproxy; as the listen socket remains open in ProxyMgr (the parent process), the kernel
+will keep accepting connections even in the window between when an old Haproxy process has stopped accepting connections and a new process has not
+yet begun accepting them.
+
+ProxyMgr will attempt to avoid reloading Haproxy whenever necessary if stats_socket is configured. This is achieved by disabling and enabling
+services through the stats socket when they become unavailable/available:
+
+* If a server is removed, ProxyMgr will disable it through the Haproxy stats socket and write out a new configuration, but not reload the process.
+* If a server which as previously been removed and disabled is added, ProxyMgr will re-enable it.
+* If a new server is added, ProxyMgr will add it to the configuration and reload Haproxy.
+* If a new backend is added, ProxyMgr will add it to the configuration and reload Haproxy.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+desc 'Run tests'
+RSpec::Core::RakeTask.new(:spec)

data/bin/proxymgr

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+
+require 'proxymgr'
+require 'yaml'
+require 'docopt'
+
+Thread.abort_on_exception = true
+
+opt = <<OPT
+ProxyMgr manages Haproxy dynamically.
+
+Usage:
+  #{__FILE__} -c=<path> | --config=<path> [-d|--debug]
+
+Options:
+  -c=<path> --config=<path>   Set configuration file path
+  -d --debug                  Turn on debug logging
+OPT
+
+begin
+  require 'pp'
+  opts = Docopt.docopt(opt)
+rescue Docopt::Exit => e
+  $stderr.puts e.message
+  exit 1
+end
+
+ProxyMgr::Logging.level = opts['--debug'] ? Logger::DEBUG : Logger::INFO
+Zoology::Logging.level = ProxyMgr::Logging.level
+
+begin
+  config = ProxyMgr::Config.new(opts['--config'])
+rescue ProxyMgr::Config::ConfigException => e
+  $stderr.puts "config file #{opts['--config']} failed to validate: #{e.message}"
+  exit 1
+end
+
+haproxy_config  = config['haproxy']
+haproxy         = ProxyMgr::Haproxy.new(haproxy_config['path'],
+                                        haproxy_config['config_path'],
+                                        :socket   => haproxy_config['socket_path'],
+                                        :global   => haproxy_config['global'],
+                                        :defaults => haproxy_config['defaults'])
+if haproxy.version < 1.5
+  $stderr.puts 'ProxyMgr requires haproxy version 1.5 or later.'
+  exit 1
+end
+
+service_manager   = nil
+begin
+  sink            = ProxyMgr::Sink.new(haproxy)
+  service_manager = ProxyMgr::ServiceManager.new(sink)
+  service_config  = ProxyMgr::ServiceConfig.create(service_manager,
+                                                   config['service_config'])
+
+  [:INT, :TERM].each do |sig|
+    Signal.trap(sig) do
+      begin
+        Thread.new { service_manager.shutdown }.join
+      rescue Exception => e
+        p e
+        p e.backtrace
+      end
+      exit 0
+    end
+  end
+
+  sleep
+rescue SystemExit
+rescue NameError, Exception => e
+  service_manager.shutdown if service_manager
+  raise e
+end

data/etc/haproxy.cfg.erb

@@ -0,0 +1,11 @@
+global
+  stats socket <%= @socket_path %> mode 666 level admin
+<% @global_config.each do |line| %>  <%= line %>
+<% end %>
+defaults
+<% @defaults_config.each do |line| %>  <%= line %>
+<% end %>
+<% @backends.each do |name, watcher| %><% next unless @file_descriptors[watcher.port] %>listen <%= name %> fd@<%= @file_descriptors[watcher.port] %><% if watcher.listen_options %><% watcher.listen_options.each do |line| %>
+  <%= line %><% end %><% end %>
+<% watcher.servers.each do |server| %>  server <%= server %> <%= server %><% if watcher.server_options %> <%= watcher.server_options.join(' ') %><% end %>
+<% end %><% end %>

data/examples/config.yml

@@ -0,0 +1,5 @@
+---
+haproxy:
+  path: /tmp/haproxy
+  config_path: /tmp/haproxy.cfg
+  socket_path: /tmp/stats.sock

data/lib/proxymgr.rb

@@ -0,0 +1,20 @@
+require 'proxymgr/logging'
+require 'proxymgr/config'
+require 'proxymgr/callbacks'
+require 'proxymgr/service_manager'
+require 'proxymgr/service_config'
+require 'proxymgr/process_manager'
+require 'proxymgr/haproxy'
+require 'proxymgr/sink'
+require 'proxymgr/watcher'
+require 'proxymgr/platform'
+
+module ProxyMgr
+  def self.root
+    File.expand_path(File.join(__FILE__, '..', '..'))
+  end
+
+  def self.template_dir
+    File.join(root, 'etc')
+  end
+end

data/lib/proxymgr/callbacks.rb

@@ -0,0 +1,17 @@
+module ProxyMgr
+  module Callbacks
+    def call(callback, *args)
+      cb = @callbacks[callback]
+      cb.call(*args) if cb
+    end
+
+    private
+
+    def callbacks(*callbacks)
+      @callbacks ||= {}
+      callbacks.each do |cb|
+        self.class.send(:define_method, cb) { |&blk| @callbacks[cb] = blk }
+      end
+    end
+  end
+end

data/lib/proxymgr/config.rb

@@ -0,0 +1,130 @@
+module ProxyMgr
+  class Config
+    require 'yaml'
+    require 'erb'
+
+    DEFAULTS = {
+      'haproxy' => {
+        'path'        => 'haproxy',
+        'config_path' => '/etc/haproxy/haproxy.cfg',
+        'socket_path' => '/var/lib/haproxy.sock',
+        'global'      => ['maxconn 4096',
+                          'log  127.0.0.1 local0',
+                          'log  127.0.0.1 local1 notice'],
+        'defaults'    => ['log global',
+                          'option dontlognull',
+                          'maxconn 2000',
+                          'retries 3',
+                          'timeout connect 5s',
+                          'timeout client 1m',
+                          'timeout server 1m',
+                          'option redispatch',
+                          'balance roundrobin']
+      }
+    }
+
+    VALIDATORS = {
+      'haproxy' => {
+        'path' => :executable,
+        'config_path' => :fullpath,
+        'socket_path' => :fullpath,
+        'global'      => :array_of_strings,
+        'default'     => :array_of_strings
+      },
+      'service_config' => {
+        'type' => :svconfig
+      }
+    }
+
+    def initialize(file)
+      data    = ERB.new(File.read(file)).result(binding)
+      @config = YAML.load(data) || {}
+
+      merge_defaults!
+      validate_config
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    private
+
+    def merge_defaults!
+      DEFAULTS.each do |key, value|
+        if @config[key]
+          @config[key] = value.merge(@config[key])
+        else
+          @config[key] = value
+        end
+      end
+    end
+
+    def validate_config
+      validate_haproxy
+      validate_svconfig
+    end
+
+    def validate_svconfig
+      validate_hash(@config['service_config'], VALIDATORS['service_config'])
+    end
+
+    def validate_haproxy
+      validate_hash(@config['haproxy'], VALIDATORS['haproxy'])
+    end
+
+    def validate_hash(data, validators)
+      fail ConfigException.new "not a hash" unless data.is_a? Hash
+
+      data.each do |key, value|
+        Validators.send(validators[key], key, value) if validators[key]
+      end
+    end
+
+    module Validators
+      class << self
+        def fullpath(key, value)
+          should("#{key} should be a valid full path") { value =~ /^\// }
+        end
+
+        def executable(key, exe)
+          should("#{key} should be an executable") do
+            if exe =~ /^\//
+              File.executable? exe
+            else
+              ENV['PATH'].split(':').find do |e|
+                File.executable? File.join(e, exe)
+              end
+            end
+          end
+        end
+
+        def array_of_strings(key, ary)
+          ary.each_with_index do |value, i|
+            should("#{key}[#{i}] should be a string") do
+              value.is_a? String
+            end
+          end
+        end
+
+        def svconfig(key, type)
+          should("#{key} should be a service config implementation") do
+            begin
+              ServiceConfig.const_get(type.capitalize)
+            rescue NameError
+              false
+            end
+          end
+        end
+
+        private
+
+        def should(reason = nil, &blk)
+          fail ConfigException.new(reason) unless blk.call
+        end
+      end
+    end
+
+    class ConfigException < Exception; end
+  end
+end