proxymgr 0.1

data/lib/proxymgr/watcher.rb

@@ -0,0 +1,9 @@
+module ProxyMgr
+  module Watcher
+    require 'proxymgr/watcher/base'
+    require 'proxymgr/watcher/dns'
+    require 'proxymgr/watcher/file'
+    require 'proxymgr/watcher/zookeeper'
+    require 'proxymgr/watcher/campanja_zk'
+  end
+end

data/lib/proxymgr/watcher/base.rb

@@ -0,0 +1,75 @@
+module ProxyMgr
+  module Watcher
+    class Base
+      attr_reader :servers, :port, :listen_options, :server_options
+
+      include Logging
+
+      def initialize(name, config, manager)
+        @name           = name
+        @manager        = manager
+        @config         = config
+
+        @servers        = []
+        @listen_options = @config['listen_options']
+        @server_options = @config['server_options']
+        @port           = @config['port']
+      end
+
+      def watch
+        fail Exception 'This method should be overridden'
+      end
+
+      def shutdown; end
+
+      def ==(obj)
+        if obj.is_a? Watcher::Base
+          obj.listen_options == @listen_options and
+            obj.server_options == @server_options and
+            obj.port == @port
+        else
+          super
+        end
+      end
+
+      def valid?
+        unless @port
+          warn 'port is not defined'
+          return false
+        end
+
+        unless @port.is_a? Integer and (@port > 0 and @port <= 65535)
+          warn 'port is not an integer or not valid'
+          return false
+        end
+
+        unless !@listen_options || @listen_options.is_a?(Array)
+          warn 'listen_options is not an array'
+          return false
+        end
+
+        unless !@server_options || @server_options.is_a?(Array)
+          warn 'server_options is not an array'
+          return false
+        end
+
+        if has_validation? and !validate_config
+          warn 'config failed to validate'
+          return false
+        end
+
+        true
+      end
+
+      private
+
+      def has_validation?
+        respond_to? :validate_config
+      end
+
+      def warn(msg)
+        logger.warn "#{@name}: #{msg}. This watcher will not start."
+      end
+    end
+  end
+end

data/lib/proxymgr/watcher/campanja_zk.rb

@@ -0,0 +1,20 @@
+module ProxyMgr
+  module Watcher
+    class Campanjazk < Zookeeper
+      def watch_zookeeper(path, type, req)
+        if type == :update
+          @zk_mapping[path] = ::File.basename(path)
+        else
+          @zk_mapping.delete(path)
+        end
+        update_servers(@zk_mapping.values.sort)
+      end
+
+      def update_servers(children)
+        servers = children.map { |child| "#{child}:#{@config['port']}" }.sort
+        @servers = servers
+        @manager.update_backends
+      end
+    end
+  end
+end

data/lib/proxymgr/watcher/dns.rb

@@ -0,0 +1,36 @@
+module ProxyMgr
+  module Watcher
+    class Dns < Base
+      require 'resolv'
+
+      private
+
+      def watch
+        @thread = Thread.new do
+          loop do
+            hosts = []
+            @config['backends'].map do |backend|
+              resolver.each_address(backend['name']) do |addr|
+                hosts << "#{addr}:#{backend['port']}"
+              end
+            end
+
+            hosts.sort!
+
+            if @servers != hosts
+              @servers = hosts
+              @manager.update_backends
+            end
+
+            sleep 5
+          end
+        end
+        @thread.abort_on_exception = true
+      end
+
+      def resolver
+        Resolv::DNS.new
+      end
+    end
+  end
+end

data/lib/proxymgr/watcher/file.rb

@@ -0,0 +1,45 @@
+module ProxyMgr
+  module Watcher
+    class File
+      attr_reader :servers
+
+      include Logging
+
+      def initialize(name, config, manager)
+        @name     = name
+        @manager  = manager
+        @config   = config
+
+        @servers  = []
+
+        @thread   = nil
+
+        watch
+      end
+
+      def shutdown
+      end
+
+      private
+
+      def watch
+        @thread = Thread.new do
+          loop do
+            if ::File.file? @config['file']
+              servers = ::File.readlines(@config['file']).map(&:chomp).sort
+              if @servers != servers
+                @servers = servers
+                @manager.update_backends
+              end
+            else
+              logger.info "#{@name} is not a file, ignoring..."
+            end
+
+            sleep 5
+          end
+        end
+        @thread.abort_on_exception = true
+      end
+    end
+  end
+end

data/lib/proxymgr/watcher/zookeeper.rb

@@ -0,0 +1,61 @@
+module ProxyMgr
+  module Watcher
+    class Zookeeper < Base
+      require 'yajl/json_gem'
+      require 'zoology'
+
+      def watch
+        @zookeeper  = Zoology::Client.new(@config['server'])
+        @path_cache = Zoology::PathCache.new(@zookeeper,
+                                             @config['path'],
+                                             &method(:watch_zookeeper))
+        @zk_mapping = {}
+        @zookeeper.connect
+      end
+
+      def shutdown
+        @zookeeper.close if @zookeeper
+      end
+
+      def validate_config
+        unless @config['path'].is_a? String and
+          @config['path'] =~ /^\// and
+          @config['path'] !~ /\/$/
+
+          logger.warn "'path' is not a valid Zookeeper path"
+          return
+        end
+
+        unless @config['server'].is_a? String and
+            @config['server'] =~ /^(?:.*:\d{1,6}){1,}$/
+          logger.warn "'server' is not properly specified"
+          return
+        end
+
+        true
+      end
+
+      private
+
+      def watch_zookeeper(path, type, req)
+        if type == :update
+          begin
+            config = JSON.parse(req[:data])
+            server = "#{config['address']}:#{config['port']}"
+            @zk_mapping[path] = server
+          rescue Exception => e
+            logger.warn "Could not parse config information for backend #{path}: #{e.message}"
+          end
+        else
+          @zk_mapping.delete(path)
+        end
+        update_servers(@zk_mapping.values.sort)
+      end
+
+      def update_servers(servers)
+        @servers = servers
+        @manager.update_backends
+      end
+    end
+  end
+end

data/packaging/profile.sh

@@ -0,0 +1 @@
+export PATH=${PATH}:/opt/proxymgr/bin

data/packaging/recipe.rb

@@ -0,0 +1,35 @@
+class ProxyMgr < FPM::Cookery::Recipe
+  gemspec = eval(File.read('../proxymgr.gemspec'))
+
+  homepage    'http://github.com/campanja/proxymgr'
+  name        'proxymgr'
+  version     gemspec.version.to_s
+  source      'none', :with => :noop
+
+  revision    '1'
+  vendor      'campanja'
+  maintainer  'Team Omega <omega@campanja.com>'
+  license     'MIT'
+
+  description 'Manages Haproxy configuration dynamically'
+  section     'admin'
+
+  depends 'ruby2.1', 'haproxy (>= 1.5)'
+
+  def build
+    File.open('Gemfile', 'w') do |fh|
+      fh.puts <<-EOF
+source "https://rubygems.org"
+
+gem '#{name}', '#{version}', :git => 'git@github.com:campanja/proxymgr.git'
+EOF
+    end
+    system 'bundle install --binstubs --standalone --path vendor/bundle'
+  end
+
+  def install
+    opt('proxymgr').install Dir['*']
+    opt('proxymgr').install Dir['.bundle']
+    etc('profile.d').install(workdir('profile.sh'), 'proxymgr.sh')
+  end
+end

data/proxymgr.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name          = 'proxymgr'
+  gem.version       = '0.1'
+  gem.authors       = ['Torbjörn Norinder']
+  gem.email         = ['torbjorn@genunix.se']
+  gem.description   = %q{Manages Haproxy configuration dynamically}
+  gem.summary       = gem.description
+  gem.homepage      = 'https://github.com/campanja/proxymgr'
+  gem.platform      = Gem::Platform::RUBY
+  gem.add_dependency 'docopt', '~> 0.5.0'
+  gem.add_dependency 'zoology'
+  gem.add_dependency 'absolute_time'
+  gem.add_dependency 'yajl-ruby'
+  gem.add_dependency 'zookeeper'
+  gem.add_dependency 'state_machine'
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'proxymgr'
+require 'support/mock_servers'
+require 'support/dummy_watcher'
+require 'support/fake_proxy'
+
+ProxyMgr::Logging.disable!
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+  config.include MockServers
+end
+

data/spec/support/dummy_watcher.rb

@@ -0,0 +1,21 @@
+module ProxyMgr
+  module Watcher
+    class Dummy < Base
+      attr_reader :name, :config, :manager
+      attr_accessor :servers
+
+      def initialize(name, config, manager, &blk)
+        @name    = name
+        @config  = config
+        @manager = manager
+        @blk     = blk
+
+        super
+      end
+
+      def watch
+        @blk.call if @blk
+      end
+    end
+  end
+end

data/spec/support/fake_proxy.rb

@@ -0,0 +1,15 @@
+module ProxyMgr
+  class FakeProxy
+    def initialize(&blk)
+      @blk      = blk
+      @backends = []
+    end
+
+    def update_backends(backends)
+      @backends = backends
+      @blk.call
+    end
+
+    def start; end
+  end
+end

data/spec/support/fake_zookeeper.rb

@@ -0,0 +1,170 @@
+class FakeZookeeper
+  require 'zookeeper'
+
+  def initialize(server, heartbeat, watcher)
+    @server    = server
+    @heartbeat = heartbeat
+    @watcher   = watcher
+
+    @connected = true
+
+    @state     = {:children => {}}
+    @watches   = {}
+  end
+
+  def reopen
+    connected!
+  end
+
+  def expired!
+    disconnected!
+    call_session(Zookeeper::ZOO_EXPIRED_SESSION_STATE)
+  end
+
+  def disconnected!
+    call_session(Zookeeper::ZOO_CONNECTING_STATE)
+    @connected = false
+  end
+
+  def connected!
+    call_session(Zookeeper::ZOO_CONNECTED_STATE)
+    @connected = true
+  end
+
+  def connected?
+    @connected
+  end
+
+  def get(opts)
+    path    = opts[:path]
+    watcher = opts[:watcher]
+
+    data = get_path(path)
+    if data
+      watch_path(path, watcher) if watcher
+      event(data)
+    else
+      event(data, Zookeeper::ZNONODE)
+    end
+  end
+
+  def set(opts)
+    path    = opts[:path]
+    data    = opts[:data]
+
+    data = set_path(path, data)
+    event = event(data)
+    fire_watches(path, event) if data
+    event
+  end
+
+  def create(opts)
+    path    = opts[:path]
+    data    = opts[:data]
+    watcher = opts[:watcher]
+
+    parts  = path.split('/')
+    name   = parts.pop
+    parent = File.join(*parts)
+
+    data = create_path(name, parent, data)
+    event = event(data)
+    fire_watches(parent, event) if data
+    watch_path(path, watcher) if watcher
+    event
+  end
+
+  def get_children(opts)
+    path    = opts[:path]
+    watcher = opts[:watcher]
+
+    data = get_children_path(path)
+    if data
+      watch_path(path, watcher) if watcher
+      {:rc       => Zookeeper::ZOK,
+       :children => data}
+    else
+      {:rc       => Zookeeper::ZNONODE}
+    end
+  end
+
+  def watcher_callback(&blk)
+    blk
+  end
+
+  private
+
+  def get_path(path)
+    node = resolve_node(path)
+    (node[:data] || "") if node
+  end
+
+  def set_path(path, set_data)
+    node = resolve_node(path)
+    node[:data] = set_data if node
+  end
+
+  def watch_path(path, watcher)
+    node = resolve_node(path)
+    if node
+      node[:watches] ||= []
+      node[:watches] << watcher
+    end
+  end
+
+  def create_path(name, parent, data)
+    node = resolve_node(parent)
+    if node
+      c = node[:children] ||= {}
+      n = c[name] ||= {}
+      if data
+        n[:data] = data
+      else
+        true
+      end
+    end
+  end
+
+  def get_children_path(path)
+    node = resolve_node(path)
+    node[:children] ? node[:children].keys : [] if node
+  end
+
+  def fire_watches(path, event = nil)
+    node = resolve_node(path)
+    node.delete(:watches).each { |w| w.call event } if node and node[:watches]
+  end
+
+  def resolve_node(path)
+    parts = path.split('/')
+    return @state if parts.size <= 1
+    parts.shift
+    leaf_name = parts.pop
+    r = parts.inject(@state[:children]) do |state, comp|
+      data = state[comp]
+      break unless data and data[:children]
+      data[:children]
+    end
+    r[leaf_name] if r
+  end
+
+  def call_session(state)
+    @watcher.call(zoo_session_event(state))
+  end
+
+  def zoo_session_event(state)
+    Event.new.tap do |e|
+      e.state = state
+      e.type  = state
+    end
+  end
+
+  def event(data, rc = Zookeeper::ZOK)
+    Event.new.tap do |e|
+      e.data = data
+      e.rc   = rc
+    end
+  end
+
+  class Event < Struct.new(:rc, :state, :data, :type); end
+end