proxymgr 0.1

data/lib/proxymgr/haproxy/updater.rb

@@ -0,0 +1,74 @@
+module ProxyMgr
+  class Haproxy
+    class Updater
+      include Logging
+
+      def initialize(socket)
+        @socket       = socket
+        @old_watchers = {}
+      end
+
+      def produce_changeset(watchers)
+        if @socket and @socket.connected?
+          new_state = Hash[watchers.map do |name, watcher|
+            [name, watcher.servers]
+          end]
+          proxy_state = haproxy_state
+          restart_needed = false
+          (proxy_state.keys + new_state.keys).uniq.each do |name|
+            if @old_watchers[name] and watchers[name]
+              restart_needed = @old_watchers[name] != watchers[name]
+            else
+              restart_needed = true
+            end
+            break if restart_needed
+          end
+          changeset = Set.new(restart_needed, {}, {})
+          diff(new_state, proxy_state, changeset) unless restart_needed
+          @old_watchers = watchers
+          changeset
+        else
+          logger.debug 'No socket, not doing diffing'
+          Set.new(true, {}, {})
+        end
+      end
+
+      private
+
+      def haproxy_state
+        @socket.servers.each_with_object({}) do |server, servers|
+          backend = servers[server.backend] ||= { :disabled => [], :enabled => [] }
+          if server.disabled?
+            backend[:disabled] << server.name
+          else
+            backend[:enabled] << server.name
+          end
+        end
+      end
+
+      def diff(new_state, proxy_state, changeset)
+        new_state.each_with_object(changeset) do |(backend, servers), cs|
+          if proxy_state[backend]
+            enabled    = proxy_state[backend][:enabled]
+            to_disable = enabled - servers
+
+            disabled  = proxy_state[backend][:disabled]
+            to_enable = (disabled & servers)
+            if ((enabled - to_disable) + to_enable).sort != servers.sort
+              cs.restart_needed = true
+            end
+
+            cs.disable[backend] = to_disable
+            cs.enable[backend]  = to_enable
+          end
+        end
+      end
+
+      class Set < Struct.new(:restart_needed, :disable, :enable)
+        def restart_needed?
+          restart_needed
+        end
+      end
+    end
+  end
+end

data/lib/proxymgr/logging.rb

@@ -0,0 +1,26 @@
+module ProxyMgr
+  module Logging
+    require 'logger'
+    require 'stringio'
+
+    def logger
+      @logger ||= Logging.logger(self.class)
+    end
+
+    class << self
+      attr_accessor :level
+
+      def disable!
+        @disable = true
+      end
+
+      def logger(name)
+        sink = @disable ? StringIO.new : STDOUT
+        logger = Logger.new(sink)
+        logger.level = @level || Logger::INFO
+        logger.progname = name
+        logger
+      end
+    end
+  end
+end

data/lib/proxymgr/platform.rb

@@ -0,0 +1,16 @@
+module ProxyMgr
+  module Platform
+    require 'proxymgr/platform/linux'
+
+    def self.method_missing(sym, *args)
+      case RUBY_PLATFORM
+      when /linux/
+        Platform::Linux.send(sym, *args)
+      else
+        fail UnsupportedPlatform "Your platform is not supported"
+      end
+    end
+
+    class UnsupportedPlatform < Exception; end
+  end
+end

data/lib/proxymgr/platform/linux.rb

@@ -0,0 +1,9 @@
+module ProxyMgr
+  module Platform
+    module Linux
+      def self.max_fd
+        File.readlines('/proc/self/status').find { |x| x =~ /^FDSize:/ }.split(':').last.to_i
+      end
+    end
+  end
+end

data/lib/proxymgr/process_manager.rb

@@ -0,0 +1,101 @@
+module ProxyMgr
+  class ProcessManager
+    require 'timeout'
+    require 'proxymgr/process_manager/signal_handler'
+
+    include Callbacks
+
+    attr_reader :exit_code, :pid
+
+    def initialize(cmd, args = [], opts = {})
+      @cmd        = cmd
+      @args       = args
+      @pid        = nil
+      @exit_code  = nil
+
+      @timeout    = opts[:timeout] || 10
+      @setsid     = opts[:setsid] || true
+      @fds        = opts[:fds] || []
+
+      @io_handler = nil
+
+      callbacks :on_stdout, :on_stderr, :on_stop
+    end
+
+    def start
+      stdout_read, stdout_write = IO.pipe
+      stderr_read, stderr_write = IO.pipe
+      sync_pipe                 = IO.pipe
+
+      @pid = Process.fork do
+        $stdout.reopen stdout_write
+        $stderr.reopen stderr_write
+        [stderr_read, stdout_read].each(&:close)
+        begin
+          Process.setsid if @setsid
+        rescue Errno::EPERM
+        end
+        sync_pipe[0].read(1)
+        3.upto(Platform.max_fd).each do |fd|
+          begin
+            IO.for_fd(fd).close unless @fds.include? fd
+          rescue ArgumentError, Errno::EBADF
+          end
+        end
+        Process.exec(*([@cmd] + @args), :close_others => false)
+      end
+      self.class.register(@pid) { |status| call(:on_stop, status) }
+      sync_pipe[1].write(1)
+      ([stdout_write, stderr_write] + sync_pipe).each(&:close)
+
+      @thread = Thread.new do
+        stop = false
+        fdset = [stdout_read, stderr_read]
+        until stop
+          r = IO.select(fdset, [], fdset).first
+          out = {}
+          r.each do |pipe|
+            stream = pipe == stdout_read ? :stdout : :stderr
+            buf = out[stream] ||= ''
+            begin
+              loop { buf << pipe.read_nonblock(4096) }
+            rescue Errno::EWOULDBLOCK
+            rescue EOFError
+              stop = true
+            end
+          end
+          out.each do |stream, buf|
+            buf.split(/\n/).each { |line| call("on_#{stream}".to_sym, line) }
+          end
+        end
+        fdset.each(&:close)
+      end
+      @thread.abort_on_exception = true
+
+      @pid
+    end
+
+    def stop
+      Process.kill('TERM', @pid)
+      begin
+        Timeout.timeout(@timeout) { wait }
+      rescue Timeout::Error
+        Process.kill('KILL', @pid)
+      end
+      @thread.join if @thread
+    end
+
+    def wait
+      begin
+        _pid, result = Process.waitpid2(@pid)
+        @exit_code = result.exitstatus || result.termsig
+      rescue Errno::ECHILD
+      end
+    end
+
+    def self.register(pid, &blk)
+      @handler ||= SignalHandler.new
+      @handler.register(pid, &blk)
+    end
+  end
+end

data/lib/proxymgr/process_manager/signal_handler.rb

@@ -0,0 +1,44 @@
+module ProxyMgr
+  class ProcessManager
+    class SignalHandler
+      include Logging
+
+      def initialize
+        @pids = {}
+
+        start
+      end
+
+      def register(pid, &blk)
+        @pids[pid] = blk
+      end
+
+      private
+
+      def start
+        Signal.trap(:CHLD) do
+          handled = {}
+          begin
+            loop do
+              pid, status = Process.waitpid2(-1, Process::WNOHANG)
+              break unless pid
+              handled[pid] = result(status)
+            end
+          rescue Errno::ECHILD
+          end
+          handled.each do |pid, result|
+            handle(pid, result)
+          end
+        end
+      end
+
+      def handle(pid, status = nil)
+        @pids.delete(pid).call(status) if @pids[pid]
+      end
+
+      def result(status)
+        status && (status.exitstatus || status.termsig)
+      end
+    end
+  end
+end

data/lib/proxymgr/service_config.rb

@@ -0,0 +1,12 @@
+module ProxyMgr
+  module ServiceConfig
+    require 'proxymgr/service_config/base'
+    require 'proxymgr/service_config/zookeeper'
+
+    def self.create(manager, config)
+      type = config.delete('type')
+      impl = ServiceConfig.const_get(type.capitalize)
+      impl.new(manager, config)
+    end
+  end
+end

data/lib/proxymgr/service_config/base.rb

@@ -0,0 +1,16 @@
+module ProxyMgr
+  module ServiceConfig
+    class Base
+      def initialize(manager, config)
+        @manager = manager
+        @config  = config
+
+        start
+      end
+
+      def start
+        fail Exception 'Should be overridden'
+      end
+    end
+  end
+end

data/lib/proxymgr/service_config/zookeeper.rb

@@ -0,0 +1,33 @@
+module ProxyMgr
+  module ServiceConfig
+    class Zookeeper < Base
+      require 'yajl/json_gem'
+      require 'zoology'
+
+      include Logging
+
+      def start
+        @services = {}
+
+        @client     = Zoology::Client.new(@config['servers'])
+        @path_cache = Zoology::PathCache.new(@client,
+                                             @config['path'],
+                                             &method(:watch))
+        @client.connect
+      end
+
+      private
+
+      def watch(path, type, req)
+        name = File.basename(path)
+        if type == :update
+          config = JSON.parse(req[:data])
+          @manager.update_service(name, config)
+        else
+          logger.debug "deleting service #{name}"
+          @manager.delete_service(name)
+        end
+      end
+    end
+  end
+end

data/lib/proxymgr/service_manager.rb

@@ -0,0 +1,53 @@
+module ProxyMgr
+  class ServiceManager
+    include Logging
+
+    def initialize(sink)
+      @services = {}
+      @sink     = sink
+
+      @service_mutex = Mutex.new
+      @sink_mutex    = Mutex.new
+    end
+
+    def update_service(name, config)
+      logger.info "Received service: #{name}"
+
+      type = config.delete('type')
+      begin
+        klass           = watcher_class(type)
+        @service_mutex.synchronize do
+          @services[name].shutdown if @services[name]
+          w = @services[name] = klass.new(name, config, self)
+          w.watch if w.valid?
+        end
+      rescue NameError
+        logger.warn "Could not find implementation for #{type}. Not adding service #{name}"
+        nil
+      end
+    end
+
+    def delete_service(name)
+      @service_mutex.synchronize do
+        svc = @services.delete(name)
+        svc.shutdown if svc
+      end
+      update_backends
+    end
+
+    def update_backends
+      @sink_mutex.synchronize { @sink.update_backends @services }
+    end
+
+    def shutdown
+      @sink.shutdown
+      @services.each { |_name, watcher| watcher.shutdown }
+    end
+
+    private
+
+    def watcher_class(type)
+      Watcher.const_get(type.capitalize)
+    end
+  end
+end

data/lib/proxymgr/sink.rb

@@ -0,0 +1,100 @@
+module ProxyMgr
+  class Sink
+    require 'absolute_time'
+
+    include Logging
+
+    def initialize(haproxy, opts = {})
+      @file            = opts[:haproxy_config_file] || '/tmp/haproxy.cfg'
+      @default_timeout = opts[:default_timeout] || 2
+      @max_timeout     = opts[:max_timeout] || 10
+      @haproxy         = haproxy
+      @timeout         = nil
+      @thread          = nil
+      @cv              = ConditionVariable.new
+      @mutex           = Mutex.new
+      @start_cv        = ConditionVariable.new
+      @start_mutex     = Mutex.new
+      @backends        = nil
+      @haproxy.start
+      start
+    end
+
+    def update_backends(backends)
+      @mutex.synchronize do
+        @backends ||= {}
+        backends.each do |name, watcher|
+          next if watcher.servers.empty?
+          @backends[name] = watcher
+        end
+        signal
+      end
+    end
+
+    def shutdown
+      @thread.kill
+      @thread.join
+      @haproxy.shutdown
+    end
+
+    private
+
+    def start
+      @thread = Thread.new do
+        t1 = nil
+        @mutex.synchronize do
+          loop do
+            started! unless started?
+
+            if @timeout && t1 && AbsoluteTime.now - t1 >= @timeout && @backends
+              @haproxy.update_backends(@backends)
+
+              @timeout = nil
+              @backends = nil
+            elsif t1
+              set_timeout
+              logger.debug "Waiting for #{@timeout}s or signal"
+            end
+
+            t1 = AbsoluteTime.now
+            logger.debug 'Waiting to be signalled'
+            wait
+          end
+        end
+      end
+      @thread.abort_on_exception = true
+
+      wait_for_started
+    end
+
+    def signal
+      @cv.signal
+    end
+
+    def wait
+      @cv.wait(@mutex, @timeout)
+    end
+
+    def set_timeout
+      @timeout = @timeout ? @timeout * @timeout : @default_timeout
+      @timeout = @max_timeout if @timeout > @max_timeout
+    end
+
+    def started?
+      @start_cv == nil
+    end
+
+    def started!
+      @start_mutex.synchronize do
+        @start_cv.signal
+        @start_cv = nil
+      end
+    end
+
+    def wait_for_started
+      @start_mutex.synchronize do
+        @start_cv.wait(@start_mutex) if @start_cv
+      end
+    end
+  end
+end