Contents

module EventMachine
  module ProxyServer
    class Connection < EventMachine::Connection

      ##### Proxy Methods
      def on_data(&blk); @on_data = blk; end
      def on_response(&blk); @on_response = blk; end
      def on_finish(&blk); @on_finish = blk; end

      ##### EventMachine
      def initialize
        @servers = {}
      end

      def receive_data(data)
        p [:connection, data]
        processed = @on_data.call(data)

        if processed.is_a? Array
          data, servers = *processed

          # guard for "unbound" servers
          servers = servers.collect {|s| @servers[s]}.compact
        else
          data = processed
          servers ||= @servers.values.compact
        end

        servers.each do |s|
          s.send_data data unless data.nil?
        end
      end

      #
      # initialize connections to backend servers
      #
      def server(name, opts)
        srv = EventMachine::connect(opts[:host], opts[:port], EventMachine::ProxyServer::Backend) do |c|
          c.name = name
          c.plexer = self
        end

        @servers[name] = srv
      end

      #
      # relay data from backend server to client
      #
      def relay_from_backend(name, data)
        p [:relay_from_backend, name, data]

        data = @on_response.call(name, data)
        send_data data unless data.nil?
      end

      def unbind
        # terminate any unfinished connections
        @servers.values.compact.each do |s|
          s.close_connection_after_writing
        end

        close_connection_after_writing
        @on_finish.call(:done) if @servers.values.compact.size.zero? if @on_finish
      end

      def unbind_backend(name)
        p [:unbind_backend, name]
        @servers[name] = nil
        @on_finish.call(name) if @on_finish
        close_connection_after_writing if @servers.values.compact.size.zero?
      end

    end
  end
end

Version data entries

1 entries across 1 versions & 1 rubygems

Version	Path
fizx-em-proxy-0.1.1	lib/em-proxy/connection.rb