protobuf 1.1.3 → 1.3.0

data/lib/protobuf/rpc/servers/evented_server.rb

@@ -1,28 +0,0 @@
-require 'protobuf/rpc/server'
-
-module Protobuf
-  module Rpc
-    class EventedServer < EventMachine::Connection
-      include Protobuf::Rpc::Server
-      include Protobuf::Logger::LogMethods
-      
-      # Initialize a new read buffer for storing client request info
-      def post_init
-        log_debug '[server] Post init, new read buffer created'
-        @stats = Protobuf::Rpc::Stat.new(:SERVER, true)
-        @stats.client = Socket.unpack_sockaddr_in(get_peername)
-        
-        @buffer = Protobuf::Rpc::Buffer.new(:read)
-        @did_respond = false
-      end
-      
-      # Receive a chunk of data, potentially flushed to handle_client
-      def receive_data(data)
-        log_debug '[server] receive_data: %s' % data
-        @buffer << data
-        handle_client if @buffer.flushed?
-      end
-
-    end
-  end
-end

data/lib/protobuf/rpc/servers/socket_server.rb

@@ -1,146 +0,0 @@
-require 'protobuf/rpc/server'
-
-module Protobuf
-  module Rpc
-    class SocketServer  
-      include Protobuf::Rpc::Server
-      include Protobuf::Logger::LogMethods
-
-
-      def self.cleanup? 
-        # every 10 connections run a cleanup routine after closing the response
-        @threads.size > (@thread_threshold - 1) && (@threads.size % @thread_threshold) == 0
-      end
-
-      def self.cleanup_threads
-        log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - start"
-
-        @threads = @threads.select do |t| 
-          if t[:thread].alive? 
-            true  
-          else
-            t[:thread].join
-            @working.delete(t[:socket])
-            false
-          end
-        end
-
-        log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - complete"
-      end
-
-      def self.log_signature
-        @log_signature ||= "server-#{self}"
-      end
-
-      def self.new_worker(socket)
-        Thread.new(socket) do |sock|
-          Protobuf::Rpc::SocketServer::Worker.new(sock) do |s|
-            s.close
-          end
-        end
-      end
-
-      def self.run(opts = {})
-        log_debug "[#{log_signature}] Run"
-        host = opts.fetch(:host, "127.0.0.1")
-        port = opts.fetch(:port, 9399)
-        backlog = opts.fetch(:backlog, 100)
-        thread_threshold = opts.fetch(:thread_threshold, 100)
-        auto_collect_timeout = opts.fetch(:auto_collect_timeout, 20)
-
-        @running = true
-        @threads = []
-        @thread_threshold = thread_threshold
-        @server = TCPServer.new(host, port)
-        @server.listen(backlog)
-        @working = []
-        @listen_fds = [@server]
-
-        while running?
-          log_debug "[#{log_signature}] Waiting for connections"
-
-          if ready_cnxns = IO.select(@listen_fds, [], [], auto_collect_timeout)
-            cnxns = ready_cnxns.first
-            cnxns.each do |client|
-              case 
-              when !running? then
-                # no-op
-              when client == @server then 
-                log_debug "[#{log_signature}] Accepted new connection"
-                client, sockaddr = @server.accept
-                @listen_fds << client
-              else 
-                if !@working.include?(client)
-                  @working << @listen_fds.delete(client)
-                  log_debug "[#{log_signature}] Working" 
-                  @threads << { :thread => new_worker(client), :socket => client }
-
-                  cleanup_threads if cleanup?
-                end
-              end
-            end
-          else
-            # Run a cleanup if select times out while waiting
-            cleanup_threads if @threads.size > 1
-          end
-        end
-
-      rescue 
-        # Closing the server causes the loop to raise an exception here
-        raise if running?
-      end
-
-      def self.running?
-        @running
-      end
-
-      def self.stop 
-        @running = false
-        @server.close if @server
-      end
-
-      class Worker 
-        include Protobuf::Rpc::Server
-        include Protobuf::Logger::LogMethods
-
-        def initialize(sock, &complete_cb)
-          @did_response = false
-          @socket = sock
-          @request = Protobuf::Socketrpc::Request.new
-          @response = Protobuf::Socketrpc::Response.new
-          @buffer = Protobuf::Rpc::Buffer.new(:read)
-          @stats = Protobuf::Rpc::Stat.new(:SERVER, true)
-          @complete_cb = complete_cb
-          log_debug "[#{log_signature}] Post init, new read buffer created"
-
-          @stats.client = Socket.unpack_sockaddr_in(@socket.getpeername)
-          @buffer << read_data 
-          log_debug "[#{log_signature}] handling request"
-          handle_client if @buffer.flushed?
-        end
-
-        def log_signature
-          @log_signature ||= "server-#{self.class}-#{object_id}"
-        end
-
-        def read_data
-          size_io = StringIO.new
-
-          while((size_reader = @socket.getc) != "-")
-            size_io << size_reader
-          end
-          str_size_io = size_io.string
-
-          "#{str_size_io}-#{@socket.read(str_size_io.to_i)}"
-        end
-
-        def send_data(data)
-          log_debug "[#{log_signature}] sending data : %s" % data
-          @socket.write(data)
-          @socket.flush
-          @complete_cb.call(@socket)
-        end
-      end
-    end
-  end
-end