bayserver-core 2.3.2 → 3.0.0

data/lib/baykit/bayserver/docker/{warp/warp_docker.rb → base/warp_base.rb}

@@ -2,25 +2,28 @@ require 'uri'
 
 require 'baykit/bayserver/agent/grand_agent'
 require 'baykit/bayserver/agent/lifecycle_listener'
+require 'baykit/bayserver/agent/multiplexer/rudder_state'
+require 'baykit/bayserver/docker/warp'
 require 'baykit/bayserver/docker/base/club_base'
-require 'baykit/bayserver/docker/warp/warp_data'
-require 'baykit/bayserver/docker/warp/warp_data_listener'
-require 'baykit/bayserver/docker/warp/warp_ship_store'
+require 'baykit/bayserver/common/warp_data'
+require 'baykit/bayserver/common/warp_ship_store'
 
 module Baykit
   module BayServer
     module Docker
-      module Warp
-        class WarpDocker  < Baykit::BayServer::Docker::Base::ClubBase
+      module Base
+        class WarpBase  < Baykit::BayServer::Docker::Base::ClubBase
+          include Baykit::BayServer::Docker::Warp # implements
 
           include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Multiplexer
           include Baykit::BayServer::Protocol
-          include Baykit::BayServer::Bcf
           include Baykit::BayServer::Util
-          include Baykit::BayServer::Docker::Warp
+          include Baykit::BayServer::Rudders
 
           class AgentListener
-            include Baykit::BayServer::Agent::LifecycleListener
+            include Baykit::BayServer::Agent::LifecycleListener # implements
+            include Baykit::BayServer::Common
 
             attr :warp_docker
 
@@ -28,25 +31,12 @@ module Baykit
               @warp_docker = dkr
             end
 
-            def add(agt)
-              @warp_docker.stores[agt.agent_id] = WarpShipStore.new(@warp_docker.max_ships);
+            def add(agt_id)
+              @warp_docker.stores[agt_id] = WarpShipStore.new(@warp_docker.max_ships);
             end
 
-            def remove(agt)
-              @warp_docker.stores.delete(agt.agent_id);
-            end
-          end
-
-
-          class WarpShipHolder
-            attr :owner_id
-            attr :ship_id
-            attr :ship
-
-            def initialize(owner_id, ship_id, ship)
-              @owner_id = owner_id
-              @ship_id = ship_id
-              @ship = ship
+            def remove(agt_id)
+              @warp_docker.stores.delete(agt_id);
             end
           end
 
@@ -55,7 +45,6 @@ module Baykit
           attr :port
           attr :warp_base
           attr :max_ships
-          attr :cur_ships
           attr :host_addr
           attr :timeout_sec
           attr :tour_list
@@ -67,13 +56,21 @@ module Baykit
           ######################################################
           # Abstract methods
           ######################################################
-          #
-          #
-          #     public abstract boolean secure();
-          #     protected abstract String protocol();
-          #     protected abstract Transporter newTransporter(ShipAgent agent, SocketChannel ch);
-          #
+          def secure
+            raise NotImplementedError.new
+          end
+
+          def protocol
+            raise NotImplementedError.new
+          end
 
+          def new_transporter(agent, rd, ship)
+            raise NotImplementedError.new
+          end
+
+          ######################################################
+          # Initialize methods
+          ######################################################
           def initialize
             super
             @scheme = nil
@@ -81,7 +78,6 @@ module Baykit
             @port = 0
             @warp_base = nil
             @max_ships = -1
-            @cur_ships = 0
             @host_addr = nil
             @tour_list = []
             @timeout_sec = -1 #  -1 means "Use harbor.socketTimeoutSec"
@@ -180,7 +176,7 @@ module Baykit
           ######################################################
 
           def arrive(tur)
-            agt = tur.ship.agent
+            agt = GrandAgent.get(tur.ship.agent_id)
             sto = get_ship_store(agt.agent_id)
 
             wsip = sto.rent()
@@ -199,12 +195,12 @@ module Baykit
                 else
                   skt = Socket.new(@host_addr[1].ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM, 0)
                 end
-                skt.nonblock = true
+                rd = IORudder.new(skt)
 
-                tp = new_transporter(agt, skt)
+                tp = new_transporter(agt, rd, wsip)
                 proto_hnd = ProtocolHandlerStore.get_store(protocol(), false, agt.agent_id).rent()
-                wsip.init_warp(skt, agt, tp, self, proto_hnd)
-                tp.init(agt.non_blocking_handler, skt, WarpDataListener.new(wsip))
+                wsip.init_warp(rd, agt.agent_id, tp, self, proto_hnd)
+
                 BayLog.debug("%s init warp ship", wsip)
                 BayLog.debug("%s Connect to %s:%d skt=%s", wsip, @host, @port, skt)
 
@@ -218,8 +214,8 @@ module Baykit
               wsip.start_warp_tour(tur)
 
               if need_connect
-                agt.non_blocking_handler.add_channel_listener(wsip.socket, tp)
-                agt.non_blocking_handler.ask_to_connect(wsip.socket, @host_addr[1])
+                agt.net_multiplexer.add_rudder_state(wsip.rudder, RudderState.new(wsip.rudder, tp))
+                agt.net_multiplexer.get_transporter(wsip.rudder).req_connect(wsip.rudder, @host_addr[1])
               end
 
             rescue SystemCallError => e
@@ -234,21 +230,18 @@ module Baykit
 
 
           ######################################################
-          # Implements WarpDocker
+          # Implements Warp
           ######################################################
-          def keep_ship(wsip)
+          def keep(wsip)
             BayLog.debug("%s keepShip: %s", self, wsip)
-            get_ship_store(wsip.agent.agent_id).keep(wsip)
+            get_ship_store(wsip.agent_id).keep(wsip)
           end
 
-          def return_ship(wsip)
+          def on_end_ship(wsip)
+            BayLog.debug("%s Return protocol handler: ", wsip)
+            get_protocol_handler_store(wsip.agent_id).Return(wsip.protocol_handler)
             BayLog.debug("%s return ship: %s", self, wsip);
-            get_ship_store(wsip.agent.agent_id).Return(wsip)
-          end
-
-          def return_protocol_handler(agt, phnd)
-            BayLog.debug("%s Return protocol handler: ", phnd)
-            get_protocol_handler_store(agt.agent_id).Return(phnd)
+            get_ship_store(wsip.agent_id).Return(wsip)
           end
 
           ######################################################

data/lib/baykit/bayserver/docker/built_in/built_in_harbor_docker.rb

@@ -4,7 +4,7 @@ require 'baykit/bayserver/docker/base/docker_base'
 require 'baykit/bayserver/constants'
 require 'baykit/bayserver/config_exception'
 
-require 'baykit/bayserver/util/groups'
+require 'baykit/bayserver/common/groups'
 require 'baykit/bayserver/util/sys_util'
 
 
@@ -19,6 +19,7 @@ module Baykit
           include Baykit::BayServer
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
           include Baykit::BayServer::Constants
 
           DEFAULT_MAX_SHIPS = 256
@@ -33,7 +34,11 @@ module Baykit
           DEFAULT_CONTROL_PORT = -1
           DEFAULT_MULTI_CORE = true
           DEFAULT_GZIP_COMP = false
-          DEFAULT_FILE_SEND_METHOD = FILE_SEND_METHOD_TAXI
+          DEFAULT_NET_MULTIPLEXER = MULTIPLEXER_TYPE_SPIDER
+          DEFAULT_FILE_MULTIPLEXER = MULTIPLEXER_TYPE_SPIDER
+          DEFAULT_LOG_MULTIPLEXER = MULTIPLEXER_TYPE_SPIDER
+          DEFAULT_CGI_MULTIPLEXER = MULTIPLEXER_TYPE_SPIDER
+          DEFAULT_RECIPIENT = RECIPIENT_TYPE_SPIDER
           DEFAULT_PID_FILE = "bayserver.pid"
 
           # Default charset
@@ -84,8 +89,20 @@ module Baykit
           # Multi core flag
           attr :multi_core
 
-          # Method to send file
-          attr :file_send_method
+          # Multiplexer type of network I/O
+          attr :net_multiplexer
+
+          # Multiplexer type of file read
+          attr :file_multiplexer
+
+          # Multiplexer type of log output
+          attr :log_multiplexer
+
+          # Multiplexer type of CGI input
+          attr :cgi_multiplexer
+
+          # Recipient type
+          attr :recipient
 
           # PID file name
           attr :pid_file
@@ -105,7 +122,11 @@ module Baykit
             @control_port = DEFAULT_CONTROL_PORT
             @multi_core = DEFAULT_MULTI_CORE
             @gzip_comp = DEFAULT_GZIP_COMP
-            @file_send_method = DEFAULT_FILE_SEND_METHOD
+            @net_multiplexer = DEFAULT_NET_MULTIPLEXER
+            @file_multiplexer = DEFAULT_FILE_MULTIPLEXER
+            @log_multiplexer = DEFAULT_LOG_MULTIPLEXER
+            @cgi_multiplexer = DEFAULT_CGI_MULTIPLEXER
+            @recipient = DEFAULT_RECIPIENT
             @pid_file = DEFAULT_PID_FILE
           end
 
@@ -128,22 +149,61 @@ module Baykit
               BayLog.warn(BayMessage.get(:CFG_MAX_SHIPS_IS_TO_SMALL, @max_ships))
             end
 
-            if @file_send_method == FILE_SEND_METHOD_SELECT and !SysUtil.support_select_file()
-              BayLog.warn(BayMessage.get(:CFG_FILE_SEND_METHOD_SELECT_NOT_SUPPORTED))
-              @file_send_method = FILE_SEND_METHOD_TAXI
+            if @net_multiplexer == MULTIPLEXER_TYPE_TAXI ||
+               @net_multiplexer == MULTIPLEXER_TYPE_TRAIN ||
+               @net_multiplexer == MULTIPLEXER_TYPE_SPIN
+              BayLog.warn(
+                BayMessage.get(
+                  :CFG_NET_MULTIPLEXER_NOT_SUPPORTED,
+                  Harbor::get_multiplexer_type_name(@net_multiplexer),
+                  Harbor::get_multiplexer_type_name(DEFAULT_NET_MULTIPLEXER)))
+              @net_multiplexer = DEFAULT_NET_MULTIPLEXER
             end
 
-            if @file_send_method == FILE_SEND_METHOD_SPIN and !SysUtil.support_nonblock_file_read()
-              BayLog.warn(BayMessage.get(:CFG_FILE_SEND_METHOD_SPIN_NOT_SUPPORTED))
-              @file_send_method = FILE_SEND_METHOD_TAXI
+            if @file_multiplexer == MULTIPLEXER_TYPE_SPIDER and !SysUtil.support_select_file ||
+               @file_multiplexer == MULTIPLEXER_TYPE_SPIN and !SysUtil.support_nonblock_file_read ||
+               @file_multiplexer == MULTIPLEXER_TYPE_TRAIN
+              BayLog.warn(
+                BayMessage.get(
+                  :CFG_FILE_MULTIPLEXER_NOT_SUPPORTED,
+                  Harbor::get_multiplexer_type_name(@file_multiplexer),
+                  Harbor::get_multiplexer_type_name(DEFAULT_FILE_MULTIPLEXER)))
+              @file_multiplexer = DEFAULT_FILE_MULTIPLEXER
             end
 
+            if @log_multiplexer == MULTIPLEXER_TYPE_SPIDER and !SysUtil.support_select_file ||
+               @log_multiplexer == MULTIPLEXER_TYPE_SPIN and !SysUtil.support_nonblock_file_write ||
+               @log_multiplexer == MULTIPLEXER_TYPE_TRAIN
+              BayLog.warn(
+                BayMessage.get(
+                  :CFG_LOG_MULTIPLEXER_NOT_SUPPORTED,
+                  Harbor::get_multiplexer_type_name(@log_multiplexer),
+                  Harbor::get_multiplexer_type_name(DEFAULT_LOG_MULTIPLEXER)))
+              @log_multiplexer = DEFAULT_LOG_MULTIPLEXER
+            end
 
-          end
+            if @log_multiplexer == MULTIPLEXER_TYPE_SPIN ||
+               @log_multiplexer == MULTIPLEXER_TYPE_PIGEON
+              BayLog.warn(
+                BayMessage.get(
+                  :CFG_CGI_MULTIPLEXER_NOT_SUPPORTED,
+                  Harbor::get_multiplexer_type_name(@cgi_multiplexer),
+                  Harbor::get_multiplexer_type_name(DEFAULT_CGI_MULTIPLEXER)))
+              @cgi_multiplexer = DEFAULT_CGI_MULTIPLEXER
+            end
 
-          #######################
-          # Implements DockerBase
-          #######################
+            if @net_multiplexer == MULTIPLEXER_TYPE_SPIDER &&
+               @recipient != RECIPIENT_TYPE_SPIDER
+              BayLog.warn(
+                BayMessage.get(
+                  :CFG_NET_MULTIPLEXER_DOES_NOT_SUPPORT_THIS_RECIPIENT,
+                  Harbor::get_multiplexer_type_name(@net_multiplexer),
+                  Harbor::get_recipient_type_name(@recipient),
+                  Harbor::get_recipient_type_name(RECIPIENT_TYPE_SPIDER)))
+              @recipient = RECIPIENT_TYPE_SPIDER
+            end
+
+          end
 
           def init_docker(dkr)
             if dkr.instance_of?(Trouble)
@@ -193,17 +253,47 @@ module Baykit
               @multi_core = StringUtil.parse_bool(kv.value)
             when "gzipcomp"
               @gzip_comp = StringUtil.parse_bool(kv.value)
-            when "sendfilemethod"
-              case kv.value.downcase()
-              when "select"
-                @file_send_method = FILE_SEND_METHOD_SELECT
-              when "spin"
-                @file_send_method = FILE_SEND_METHOD_SPIN
-              when "taxi"
-                @file_send_method = FILE_SEND_METHOD_TAXI
-              else
-                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+
+            when "netmultiplexer"
+              begin
+                @net_multiplexer = Harbor::get_multiplexer_type(kv.value.downcase)
+              rescue => e
+                BayLog.error_e(e)
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage::get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
               end
+
+            when "filemultiplexer"
+              begin
+                @file_multiplexer = Harbor::get_multiplexer_type(kv.value.downcase)
+              rescue => e
+                BayLog.error_e(e)
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage::get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+
+            when "logmultiplexer"
+              begin
+                @log_multiplexer = Harbor.get_multiplexer_type(kv.value.downcase)
+              rescue => e
+                BayLog.error_e(e)
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage::get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+
+            when "cgimultiplexer"
+              begin
+                @cgi_multiplexer = Harbor.get_multiplexer_type(kv.value.downcase)
+              rescue => e
+                BayLog.error_e(e)
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage::get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+
+            when "recipient"
+              begin
+                @recipient = Harbor.get_recipient_type(kv.value.downcase)
+              rescue => e
+                BayLog.error_e(e)
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage::get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+
             when "pidfile"
               @pid_file = kv.value
             else
@@ -212,13 +302,10 @@ module Baykit
             true
           end
 
-          def trace_header?
-            @trace_header
-          end
+          #######################
+          # Implements Harbor
+          #######################
 
-          def multi_core?
-            @multi_core
-          end
         end
       end
     end

data/lib/baykit/bayserver/docker/built_in/built_in_log_docker.rb

@@ -1,7 +1,8 @@
 require 'baykit/bayserver/agent/grand_agent'
 require 'baykit/bayserver/agent/lifecycle_listener'
-require 'baykit/bayserver/agent/transporter/plain_transporter'
-require 'baykit/bayserver/agent/transporter/spin_write_transporter'
+require 'baykit/bayserver/agent/multiplexer/plain_transporter'
+require 'baykit/bayserver/agent/multiplexer/rudder_state'
+require 'baykit/bayserver/rudders/io_rudder'
 require 'baykit/bayserver/docker/built_in/write_file_taxi'
 require 'baykit/bayserver/docker/log'
 require 'baykit/bayserver/docker/built_in/log_items'
@@ -14,15 +15,18 @@ module Baykit
         module BuiltIn
           class BuiltInLogDocker < Baykit::BayServer::Docker::Base::DockerBase
             include Baykit::BayServer::Docker::Log # implements
-            include Baykit::BayServer::Agent::Transporter
-            include Baykit::BayServer::Agent
-            include Baykit::BayServer::Util
 
+            include Baykit::BayServer::Docker
+            include Baykit::BayServer::Util
             include Baykit::BayServer::Bcf
+            include Baykit::BayServer::Agent
 
             class AgentListener
+              include Baykit::BayServer::Agent::Multiplexer
               include Baykit::BayServer::Agent::LifecycleListener  # implements
               include Baykit::BayServer::Agent::Transporter
+              include Baykit::BayServer::Agent
+              include Baykit::BayServer::Rudders
 
               attr :log_docker
 
@@ -30,48 +34,58 @@ module Baykit
                 @log_docker = dkr
               end
 
-              def add(agt)
-                file_name = "#{@log_docker.file_prefix}_#{agt.agent_id}.#{@log_docker.file_ext}";
+              def add(agt_id)
+                file_name = "#{@log_docker.file_prefix}_#{agt_id}.#{@log_docker.file_ext}"
+                size = 0
+                if ::File.exist?(file_name)
+                  size = ::File.size(file_name)
+                end
+                agt = GrandAgent.get(agt_id)
 
-                boat = LogBoat.new()
+                begin
+                  f = File.open(file_name, "a")
+                rescue => e
+                  BayLog.fatal(BayMessage.get(:INT_CANNOT_OPEN_LOG_FILE, file_name))
+                  BayLog.fatal_e(e);
+                end
 
-                case @log_docker.log_write_method
-                when LOG_WRITE_METHOD_SELECT
-                  tp = PlainTransporter.new(false, 0, true)  # write only
-                  tp.init(agt.non_blocking_handler, File.open(file_name, "a"), boat)
+                rd = IORudder.new(f)
 
-                when LOG_WRITE_METHOD_SPIN
-                  tp = SpinWriteTransporter.new()
-                  tp.init(agt.spin_handler, File.open(file_name, "a"), boat)
+                case BayServer::harbor.log_multiplexer
+                when Harbor::MULTIPLEXER_TYPE_TAXI
+                  mpx = agt.taxi_multiplexer
 
-                when LOG_WRITE_METHOD_TAXI
-                  tp = WriteFileTaxi.new()
-                  tp.init(agt.agent_id, File.open(file_name, "a"), boat)
+                when Harbor::MULTIPLEXER_TYPE_SPIN
+                  mpx = agt.spin_multiplexer
 
-                end
+                when Harbor::MULTIPLEXER_TYPE_SPIDER
+                  mpx = agt.spider_multiplexer
 
-                begin
-                  boat.init(file_name, tp)
-                rescue IOError => e
-                  BayLog.fatal(BayMessage.get(:INT_CANNOT_OPEN_LOG_FILE, file_name));
-                  BayLog.fatal_e(e);
+                when Harbor::MULTIPLEXER_TYPE_JOB
+                  mpx = agt.job_multiplexer
+
+                else
+                  raise Sink.new
                 end
 
-                @log_docker.loggers[agt.agent_id] = boat
+                st = RudderState.new(rd)
+                st.bytes_wrote = size
+                mpx.add_rudder_state(rd, st)
+
+                @log_docker.multiplexers[agt_id] = mpx
+                @log_docker.rudders[agt_id] = rd
               end
 
 
-              def remove(agt)
-                @log_docker.loggers.delete(agt.agent_id);
+              def remove(agt_id)
+                rd = @log_docker.rudders[agt_id]
+                @log_docker.multiplexers[agt_id].req_close(rd)
+                @log_docker.multiplexers[agt_id] = nil
+                @log_docker.rudders[agt_id] = nil
               end
             end
 
 
-            LOG_WRITE_METHOD_SELECT = 1
-            LOG_WRITE_METHOD_SPIN = 2
-            LOG_WRITE_METHOD_TAXI = 3
-            DEFAULT_LOG_WRITE_METHOD = LOG_WRITE_METHOD_TAXI
-
             class << self
               # Mapping table for format
               attr :log_item_map
@@ -91,14 +105,17 @@ module Baykit
             # Log items
             attr :log_items
 
-            # Log write method
-            attr :log_write_method
+            attr :rudders
+
+            # Multiplexer to write to file
+            attr :multiplexers
 
             def initialize
               @loggers = {}
               @format = nil
               @log_items = []
-              @log_write_method = DEFAULT_LOG_WRITE_METHOD
+              @rudders = {}
+              @multiplexers = {}
             end
 
             def init(elm, parent)
@@ -130,17 +147,6 @@ module Baykit
               # Parse format
               compile(@format, @log_items, elm.file_name, elm.line_no)
 
-              # Check log write method
-              if @log_write_method == LOG_WRITE_METHOD_SELECT and !SysUtil.support_select_file()
-                BayLog.warn(BayMessage.get(:CFG_LOG_WRITE_METHOD_SELECT_NOT_SUPPORTED))
-                @log_write_method = LOG_WRITE_METHOD_TAXI
-              end
-
-              if @log_write_method == LOG_WRITE_METHOD_SPIN and !SysUtil.support_nonblock_file_write()
-                BayLog.warn(BayMessage.get(:CFG_LOG_WRITE_METHOD_SPIN_NOT_SUPPORTED))
-                @log_write_method = LOG_WRITE_METHOD_TAXI
-              end
-
               GrandAgent.add_lifecycle_listener(AgentListener.new(self));
             end
 
@@ -148,17 +154,7 @@ module Baykit
               case kv.key.downcase
               when "format"
                 @format = kv.value
-              when "logwritemethod"
-                case kv.value.downcase()
-                when "select"
-                  @log_write_method = LOG_WRITE_METHOD_SELECT
-                when "spin"
-                  @log_write_method = LOG_WRITE_METHOD_SPIN
-                when "taxi"
-                  @log_write_method = LOG_WRITE_METHOD_TAXI
-                else
-                  raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
-                end
+
               else
                 return false
               end
@@ -178,17 +174,18 @@ module Baykit
 
               # If threre are message to write, write it
               if sb.length > 0
-                get_logger(tour.ship.agent).log(sb)
+                @multiplexers[tour.ship.agent_id].req_write(
+                  @rudders[tour.ship.agent_id],
+                  sb,
+                  nil,
+                  "log",
+                  nil
+                )
               end
             end
 
             private
 
-            def get_logger(agt)
-              return @loggers[agt.agent_id]
-            end
-
-
 
             #
             # Compile format pattern

data/lib/baykit/bayserver/docker/built_in/built_in_permission_docker.rb

@@ -3,7 +3,7 @@ require 'ipaddr'
 require 'baykit/bayserver/http_exception'
 require 'baykit/bayserver/bcf/package'
 require 'baykit/bayserver/docker/permission'
-require 'baykit/bayserver/util/groups'
+require 'baykit/bayserver/common/groups'
 require 'baykit/bayserver/util/headers'
 require 'baykit/bayserver/util/http_status'
 require 'baykit/bayserver/util/host_matcher'
@@ -20,6 +20,7 @@ module Baykit
           include Baykit::BayServer
           include Baykit::BayServer::Bcf
           include Baykit::BayServer::Util
+          include Baykit::BayServer::Common
 
           class CheckItem
             attr :matcher
@@ -30,8 +31,8 @@ module Baykit
               @admit = admit
             end
 
-            def socket_admitted(skt)
-              matcher.match_socket(skt) == @admit
+            def socket_admitted(rd)
+              matcher.match_socket(rd) == @admit
             end
 
             def tour_admitted(tur)
@@ -41,12 +42,12 @@ module Baykit
 
           module PermissionMatcher # interface
 
-            def match_socket(skt)
-              raise NotImplementedError()
+            def match_socket(rd)
+              raise NotImplementedError.new
             end
 
             def match_tour(tur)
-              raise NotImplementedError()
+              raise NotImplementedError.new
             end
           end
 
@@ -61,8 +62,8 @@ module Baykit
               @mch = HostMatcher.new(hostPtn)
             end
 
-            def match_socket(skt)
-              return @mch.match(skt.remote_address.getnameinfo[0])
+            def match_socket(rd)
+              return @mch.match(rd.io.remote_address.getnameinfo[0])
             end
 
             def match_tour(tur)
@@ -80,8 +81,8 @@ module Baykit
               @mch = IpMatcher.new(ip_desc)
             end
 
-            def match_socket(skt)
-              return @mch.match(@mch.get_ip_addr(skt.remote_address.ip_address))
+            def match_socket(rd)
+              return @mch.match(rd.io.remote_address.ip_address)
             end
 
             def match_tour(tur)