proxymgr 0.1

data/lib/proxymgr/haproxy.rb

@@ -0,0 +1,51 @@
+module ProxyMgr
+  class Haproxy
+    require 'proxymgr/haproxy/socket'
+    require 'proxymgr/haproxy/updater'
+    require 'proxymgr/haproxy/server'
+    require 'proxymgr/haproxy/control'
+    require 'proxymgr/haproxy/process'
+    require 'proxymgr/haproxy/state'
+    require 'proxymgr/haproxy/socket_manager'
+
+    def initialize(path, config_file, opts = {})
+      @path             = path
+      @config_file      = config_file
+
+      @socket_path      = opts[:socket]
+      @global_config    = opts[:global]
+      @defaults_config  = opts[:defaults]
+
+      @socket           = @socket_path ? Socket.new(@socket_path) : nil
+
+      @control          = nil
+    end
+
+    def version
+      `#{@path} -v`[/version ([\d\.]+)/, 1].to_f
+    end
+
+    def start
+      @socket         = @socket_path ? Socket.new(@socket_path) : nil
+      @control        = Control.new(@path, @config_file)
+      opts            = {:defaults    => @defaults_config,
+                         :global      => @global_config,
+                         :socket_path => @socket_path}
+      @socket_manager = SocketManager.new
+      @state          = State.new(@control, @config_file, @socket_manager, @socket, opts)
+      @updater        = Updater.new(@socket)
+
+      @state.start
+    end
+
+    def shutdown
+      @state.stop
+      @socket_manager.shutdown
+    end
+
+    def update_backends(watchers)
+      changeset = @updater.produce_changeset(watchers)
+      @state.update_state(watchers, changeset)
+    end
+  end
+end

data/lib/proxymgr/haproxy/control.rb

@@ -0,0 +1,46 @@
+module ProxyMgr
+  class Haproxy
+    class Control
+      include Callbacks
+
+      attr_reader :exit_code
+
+      def initialize(path, config_file)
+        @path        = path
+        @config_file = config_file
+
+        @mutex       = Mutex.new
+
+        callbacks :on_stop
+      end
+
+      def start
+        restart
+      end
+
+      def restart(fds = [])
+        @mutex.synchronize do
+          if @process
+            run(@process.pid, fds)
+          else
+            run(nil, fds)
+          end
+        end
+      end
+
+      [:wait, :stop, :exited?].each do |sym|
+        define_method(sym) { |*args, &blk| @process.send(sym, *args, &blk) }
+      end
+
+      private
+
+      def run(pid = nil, fds = [])
+        @process.replace if @process
+        @process = Process.new(@path, @config_file, fds, pid) do |status|
+          call(:on_stop, status)
+        end
+        @process.start
+      end
+    end
+  end
+end

data/lib/proxymgr/haproxy/process.rb

@@ -0,0 +1,107 @@
+module ProxyMgr
+  class Haproxy
+    class Process
+      require 'state_machine'
+
+      include Logging
+
+      state_machine :state, :initial => :stopped do
+        event :start do
+          transition [:stopped, :exited] => :running, :if => :run
+        end
+
+        event :exited do
+          transition :running => :exited
+        end
+
+        event :stop do
+          transition :running => :shutdown
+        end
+
+        after_transition :running => :shutdown do |process|
+          process.stopping
+          process.process_manager.stop
+        end
+
+        event :replace do
+          transition :running => :stopping
+        end
+
+        event :stopping do
+          transition :shutdown => :stopping
+        end
+
+        event :stopped do
+          transition :stopping => :stopped
+        end
+
+        state :running do
+          def handle_stop(status)
+            @exit_code = status
+            if abnormal_exit?
+              exited
+            else
+              stopped
+            end
+            @callback.call status
+          end
+        end
+
+        state :stopping do
+          def handle_stop(status)
+            @exit_code = status
+            stopped
+          end
+        end
+      end
+
+      attr_reader :exit_code, :process_manager
+
+      def initialize(path, config_file, fds, old_pid = nil, &callback)
+        @path        = path
+        @config_file = config_file
+        @old_pid     = old_pid
+        @callback    = callback
+        @fds         = fds
+
+        super()
+      end
+
+      [:pid, :wait].each do |sym|
+        define_method(sym) { @process_manager.send(sym) }
+      end
+
+      private
+
+      def abnormal_exit?
+        @exit_code && @exit_code > 0
+      end
+
+      def run
+        args = ['-f', @config_file, '-db']
+        if @old_pid
+          args << '-sf'
+          args << @old_pid.to_s
+        end
+
+        @process_manager = ProcessManager.new(@path, args, :fds => @fds)
+        [:on_stdout, :on_stderr].each do |cb|
+          @process_manager.send(cb, &method(:parse_haproxy_log))
+        end
+        @process_manager.on_stop(&method(:handle_stop))
+        @process_manager.start
+      end
+
+      def parse_haproxy_log(line)
+        matches = line.scan(/^\[(.*)\] (.*)/)[0]
+        if matches
+          haproxy_level, msg = matches
+          level = haproxy_level == 'WARNING' ? :warn : :info
+          logger.send(level, msg)
+        else
+          logger.info(line)
+        end
+      end
+    end
+  end
+end

data/lib/proxymgr/haproxy/server.rb

@@ -0,0 +1,24 @@
+module ProxyMgr
+  class Haproxy
+    class Server
+      attr_reader :stats
+
+      def initialize(haproxy, stats)
+        @haproxy = haproxy
+        @stats   = stats
+      end
+
+      def backend
+        @stats['pxname']
+      end
+
+      def name
+        @stats['svname']
+      end
+
+      def disabled?
+        @stats['status'] == 'MAINT'
+      end
+    end
+  end
+end

data/lib/proxymgr/haproxy/socket.rb

@@ -0,0 +1,67 @@
+module ProxyMgr
+  class Haproxy
+    class Socket
+      require 'socket'
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def stats
+        headers, *rest = write('show stat')
+        headers = headers.gsub(/^# /, '').split(',')
+        rest.pop
+        rest.map { |d| Hash[headers.zip(d.split(','))] }
+      end
+
+      def enable(backend, host)
+        write "enable server #{backend}/#{host}"
+      end
+
+      def disable(backend, host)
+        write "disable server #{backend}/#{host}"
+      end
+
+      def shutdown(backend, host)
+        write "shutdown sessions server #{backend}/#{host}"
+      end
+
+      def servers
+        stats.each_with_object([]) do |stat, acc|
+          next if %w(FRONTEND BACKEND).include? stat['svname']
+          acc << Server.new(self, stat)
+        end
+      end
+
+      def write(cmd)
+        with do |socket|
+          socket.puts(cmd + "\n")
+          socket.readlines.map(&:chomp)
+        end
+      end
+
+      def connected?
+        begin
+          with do |socket|
+            socket.write "show info"
+          end
+        rescue Errno::ECONNREFUSED
+        end
+      end
+
+      private
+
+      def with
+        socket = nil
+        begin
+          socket = UNIXSocket.new(@path)
+          yield socket
+        ensure
+          socket.close if socket
+        end
+      end
+    end
+  end
+end

data/lib/proxymgr/haproxy/socket_manager.rb

@@ -0,0 +1,62 @@
+module ProxyMgr
+  class Haproxy
+    class SocketManager
+      require 'socket'
+      require 'fcntl'
+
+      include Logging
+
+      attr_reader :sockets
+
+      def initialize
+        @sockets = {}
+      end
+
+      def shutdown
+        @sockets.each do |_port, socket|
+          socket.close
+        end
+      end
+
+      def update(backends)
+        fds = backends.each_with_object({}) do |(name, backend), mapping|
+          socket = for_port(backend.port)
+          mapping[backend.port] = socket.fileno if socket
+        end
+
+        (@sockets.keys - fds.keys).each do |port|
+          @sockets.delete(port).close
+        end
+
+        fds
+      end
+
+      private
+
+      def for_port(port)
+        unless @sockets[port]
+          @sockets[port] = ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0)
+          @sockets[port].setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, 1)
+          retries = 0
+          until retries > 5
+            begin
+              @sockets[port].bind(::Socket.pack_sockaddr_in(port, '0.0.0.0'))
+              break
+            rescue Errno::EADDRINUSE
+              logger.info "Could not bind to #{port}: retrying..."
+              sleep 1
+              retries += 1
+            end
+          end
+          flags = @sockets[port].fcntl(Fcntl::F_GETFD) & ~Fcntl::FD_CLOEXEC
+          @sockets[port].fcntl(Fcntl::F_SETFD, flags)
+        end
+        @sockets[port]
+      end
+
+      def stop_port(port)
+        @sockets[port].close if @sockets[port]
+      end
+    end
+  end
+end

data/lib/proxymgr/haproxy/state.rb

@@ -0,0 +1,124 @@
+module ProxyMgr
+  class Haproxy
+    class State
+      require 'tempfile'
+      require 'pathname'
+      require 'erb'
+
+      include Logging
+
+      def initialize(process, config_file, socket_manager, socket = nil, opts = {})
+        @process         = process
+        @config_file     = config_file
+        @socket          = socket
+        @socket_manager  = socket_manager
+
+        @sleep_interval  = opts[:sleep_interval] || 5
+        @global_config   = opts[:global]
+        @defaults_config = opts[:defaults]
+        @socket_path     = opts[:socket_path]
+
+        @file_descriptors = {}
+        @backends         = {}
+        @config_template  = ERB.new(File.read(File.join(ProxyMgr.template_dir, 'haproxy.cfg.erb')))
+        @mutex            = Mutex.new
+        @cv               = ConditionVariable.new
+      end
+
+      def start
+        write_config
+
+        @thread = Thread.new do
+          @mutex.synchronize do
+            sleep_interval = nil
+            loop do
+              logger.debug "Waiting..."
+              wait(sleep_interval)
+
+              restart_needed = true
+
+              if @changeset or @backends
+                if @changeset
+                  update_state_with_changeset
+                  restart_needed = @changeset.restart_needed?
+                end
+                @file_descriptors = @socket_manager.update(@backends)
+                write_config
+                @changeset = nil
+                @backends  = nil
+              elsif @process.exited? and !sleep_interval
+                sleep_interval = @sleep_interval
+                logger.info "Haproxy exited abnormally. Sleeping for #{sleep_interval}s"
+                next
+              end
+
+              sleep_interval = nil
+              @process.restart(@file_descriptors.values) if restart_needed
+            end
+          end
+        end
+        @thread.abort_on_exception = true
+
+        @process.on_stop do |status|
+          Thread.new { signal }.join if @process.exited?
+        end
+        @process.start
+      end
+
+      def socket?
+        @socket and @socket.connected?
+      end
+
+      def update_state(backends, changeset)
+        @mutex.synchronize do
+          @changeset = changeset
+          @backends  = backends
+        end
+        signal
+      end
+
+      def stop
+        @thread.kill
+        signal
+        @thread.join
+        begin
+          @process.stop
+        rescue Errno::ESRCH # sometimes there's no process here. that's OK.
+        end
+      end
+
+      private
+
+      def update_state_with_changeset
+        @changeset.disable.each do |backend, hosts|
+          hosts.each { |host| @socket.disable backend, host }
+        end
+
+        @changeset.enable.each do |backend, hosts|
+          hosts.each { |host| @socket.enable backend, host }
+        end
+      end
+
+      def signal
+        @mutex.synchronize { @cv.signal }
+      end
+
+      def wait(timeout = nil)
+        @cv.wait(@mutex, timeout)
+      end
+
+      def write_config
+        f = nil
+        begin
+          f = Tempfile.new('haproxy')
+          f.write @config_template.result(binding)
+          f.close
+          Pathname.new(f.path).rename(@config_file)
+        rescue Exception => e
+          logger.warn "Unable to write to #{@config_file}: #{e}"
+          File.unlink f.path if f
+        end
+      end
+    end
+  end
+end