bayserver-core 2.3.2 → 3.0.1

data/lib/baykit/bayserver/agent/multiplexer/multiplexer_base.rb

@@ -0,0 +1,150 @@
+require 'baykit/bayserver/bay_log'
+require 'baykit/bayserver/common/multiplexer'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class MultiplexerBase
+          include Baykit::BayServer::Common::Multiplexer # implements
+          include Baykit::BayServer
+
+          attr :channel_count
+          attr :agent
+          attr :rudders
+          attr :rudders_lock
+          attr :lock
+
+          def initialize(agt)
+            @agent = agt
+            @channel_count = 0
+            @rudders = {}
+            @rudders_lock = Mutex::new
+            @lock = Mutex::new
+          end
+
+          #########################################
+          # Implements Multiplexer
+          #########################################
+
+          def add_rudder_state(rd, st)
+            st.multiplexer = self
+            @rudders_lock.synchronize do
+              @rudders[rd.key] = st
+            end
+            @channel_count += 1
+            st.access()
+          end
+
+          def get_rudder_state(rd)
+            return find_rudder_state_by_key(rd.key)
+          end
+
+          def get_transporter(rd)
+            return get_rudder_state(rd).transporter
+          end
+
+          def consume_oldest_unit(st)
+            u = nil
+            st.write_queue_lock.synchronize do
+              if st.write_queue.empty?
+                return false
+              end
+              u = st.write_queue.shift()
+            end
+            u.done()
+            return true
+          end
+
+          def close_rudder(st)
+            BayLog.debug("%s closeRd %s state=%s closed=%s", agent, st.rudder, st, st.closed)
+
+            @lock.synchronize do
+              if st.closed
+                return
+              end
+              st.closed = true
+            end
+
+            remove_rudder_state(st.rudder)
+
+            begin
+              st.rudder.close()
+            rescue IOError => e
+              Baylog.error_e(e)
+            end
+
+            while consume_oldest_unit(st) do
+
+            end
+
+            if st.transporter != nil
+              st.transporter.on_closed(st.rudder)
+            end
+          end
+
+          def is_busy()
+            return @channel_count >= @agent.max_inbound_ships
+          end
+
+
+          #########################################
+          # Custom methods
+          #########################################
+
+          def find_rudder_state_by_key(key)
+            @rudders_lock.synchronize do
+              return @rudders[key]
+            end
+          end
+
+          def remove_rudder_state(rd)
+            @rudders_lock.synchronize do
+              @rudders.delete(rd.key())
+            end
+            @channel_count -= 1
+          end
+
+          def close_timeout_sockets
+            if @rudders.empty?
+              return
+            end
+
+            close_list = []
+            copied = nil
+            @rudders_lock.synchronize do
+              copied = @rudders.values
+            end
+            now = Time.now.tv_sec
+
+            copied.each do |st|
+              if st.transporter != nil
+                duration =  now - st.last_access_time
+                if st.transporter.check_timeout(st.rudder, duration)
+                  BayLog.debug("%s timeout: ch=%s", @agent, st.rudder)
+                  close_list << st
+                end
+              end
+            end
+
+            close_list.each do |st|
+              close_rudder(st)
+            end
+          end
+
+          def close_all()
+            copied = nil
+            @rudders_lock.synchronize do
+              copied = @rudders.values
+            end
+            copied.each do |st|
+              if st.rudder != @agent.command_receiver.rudder
+                close_rudder(st)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/plain_transporter.rb

@@ -0,0 +1,129 @@
+require 'baykit/bayserver/agent/multiplexer/transporter'
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/agent/next_socket_action'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class PlainTransporter
+          include Transporter   # Implements
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Util
+
+          attr :multiplexer
+          attr :server_mode
+          attr :trace_ssl
+          attr :read_buffer_size
+          attr :ship
+          attr :closed
+
+          def initialize(mpx, sip, server_mode, bufsiz, trace_ssl)
+            @multiplexer = mpx
+            @ship = sip
+            @server_mode = server_mode
+            @trace_ssl = trace_ssl
+            @read_buffer_size = bufsiz
+            @closed = false
+          end
+
+          def to_s
+            return "tp[#{@ship}]"
+          end
+
+          #########################################
+          # Implements Transporter
+          #########################################
+
+          def init
+
+          end
+
+          def on_connect(rd)
+            BayLog.trace("%s onConnect", self)
+
+            return @ship.notify_connect
+            ;
+          end
+
+          def on_read(rd, buf, adr)
+            BayLog.debug("%s onRead", self)
+
+            if buf.length == 0
+              return @ship.notify_eof
+            else
+              begin
+                return @ship.notify_read(buf)
+
+              rescue UpgradeException => e
+                BayLog.debug("%s Protocol upgrade", @ship)
+                return @ship.notify_read(buf)
+
+              rescue ProtocolException => e
+                close = @ship.notify_protocol_error(e)
+                if !close && @server_mode
+                  return NextSocketAction::CONTINUE
+                else
+                  return NextSocketAction::CLOSE
+                end
+
+              rescue IOError => e
+                # IOError which occur in notifyRead must be distinguished from
+                # IOError which occur in handshake or readNonBlock.
+                on_error(rd, e)
+                return NextSocketAction::CLOSE
+              end
+            end
+          end
+
+          def on_error(rd, e)
+            @ship.notify_error(e)
+          end
+
+          def on_closed(rd)
+            @ship.notify_close
+          end
+
+          def req_connect(rd, adr)
+            @multiplexer.req_connect(rd, adr)
+          end
+
+          def req_read(rd)
+            @multiplexer.req_read(rd)
+          end
+
+          def req_write(rd, buf, adr, tag, &lis)
+            @multiplexer.req_write(rd, buf, adr, tag, lis)
+          end
+
+          def req_close(rd)
+            @closed = true
+            @multiplexer.req_close(rd)
+          end
+
+          def check_timeout(rd, duration_sec)
+            return @ship.check_timeout(duration_sec)
+          end
+
+          def get_read_buffer_size
+            return @read_buffer_size
+          end
+
+          def print_usage(indent)
+          end
+
+
+          #########################################
+          # Custom methods
+          #########################################
+          def secure()
+            return false
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/agent/multiplexer/rudder_state.rb

@@ -0,0 +1,81 @@
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class RudderState
+          attr :rudder
+          attr :transporter
+          attr_accessor :multiplexer
+
+          attr :last_access_time
+          attr_accessor :closing
+
+          attr :read_buf
+          attr :buf_size
+          attr :write_queue
+          attr_accessor :handshaking
+          attr_accessor :reading
+          attr_accessor :writing
+          attr_accessor :bytes_read
+          attr_accessor :bytes_wrote
+          attr :write_queue_lock
+          attr :reading_lock
+          attr :writing_lock
+          attr_accessor :closed
+          attr_accessor :finale
+
+          attr_accessor :accepting
+          attr_accessor :connecting
+
+
+          def initialize(rd, tp = nil, timeout_sec = 0)
+            @rudder = rd
+            @transporter = tp
+            @closed = false
+            @timeout_sec = timeout_sec
+
+            if tp != nil
+              @buf_size = tp.get_read_buffer_size
+              @handshaking = tp.secure() ? true : false
+            else
+              @buf_size = 8192
+              @handshaking = false
+            end
+            @read_buf = " ".b * @buf_size
+
+            @accepting = false
+            @connecting = false
+            @closing = false
+            @write_queue = []
+            @write_queue_lock = Mutex::new
+            @reading_lock = Mutex::new
+            @writing_lock = Mutex::new
+            @reading = false
+            @writing = false
+            @bytes_read = 0
+            @bytes_wrote = 0
+          end
+
+          def to_s
+            str = "st(rd=#{@rudder} mpx=#{@multiplexer} tp=#{@transporter})"
+            if @closing
+              str += " closing";
+            end
+            return str
+          end
+
+
+          def access
+            @last_access_time = Time.now.tv_sec
+          end
+
+          def end
+            @finale = true
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/secure_transporter.rb

@@ -0,0 +1,50 @@
+require 'openssl'
+
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
+require 'baykit/bayserver/agent/next_socket_action'
+
+module Baykit
+  module BayServer
+    module Agent
+        module Multiplexer
+          class SecureTransporter < PlainTransporter
+            include OpenSSL
+            include Baykit::BayServer::Protocol
+
+            attr :sslctx
+
+            def initialize(mpx, sip, server_mode, bufsize, trace_ssl, sslctx)
+              super(mpx, sip, server_mode, bufsize, trace_ssl)
+              @sslctx = sslctx
+            end
+
+
+            def to_s()
+              "stp[#{@ship}]"
+            end
+
+            ######################################################
+            # Implements Transporter
+            ######################################################
+
+            def secure()
+              return true
+            end
+
+            def on_read(rd, buf, len)
+              super
+            end
+
+            ######################################################
+            # Custom methods
+            ######################################################
+
+            def new_ssl_socket(skt)
+              SSL::SSLSocket.new(skt, @sslctx)
+            end
+          end
+        end
+
+    end
+  end
+end