bayserver-core 2.3.2 → 3.0.1

data/lib/baykit/bayserver/docker/send_file/send_file_ship.rb

@@ -0,0 +1,92 @@
+require 'baykit/bayserver/common/read_only_ship'
+
+module Baykit
+  module BayServer
+    module Docker
+      module SendFile
+        class SendFileShip < Baykit::BayServer::Common::ReadOnlyShip
+          include Baykit::BayServer::Tours::ReqContentHandler   # implements
+
+          attr :file_wrote_len
+          attr :tour
+          attr :tour_id
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Multiplexer
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Rudders
+
+          attr :path
+          attr :abortable
+
+          def init(rd, tp, tur)
+            super(tur.ship.agent_id, rd, tp)
+            @file_wrote_len = 0
+            @tour = tur
+            @tour_id = tur.tour_id
+          end
+
+          ######################################################
+          # Implements Reusable
+          ######################################################
+
+          def reset
+            super
+            @file_wrote_len = 0
+            @tour_id = 0
+            @tour = nil
+          end
+
+          ######################################################
+          # Implements ReqContentHandler
+          ######################################################
+
+          def notify_read(buf)
+            @file_wrote_len += buf.length
+            BayLog.debug("%s read file %d bytes: total=%d", self, buf.length, @file_wrote_len)
+
+            begin
+              available = @tour.res.send_res_content(@tour_id, buf, 0, buf.length)
+
+              if available
+                return NextSocketAction::CONTINUE
+              else
+                return NextSocketAction::SUSPEND
+              end
+            rescue IOError => e
+              notify_error(e)
+              return NextSocketAction::CLOSE
+            end
+          end
+
+          def notify_error(e)
+            BayLog.debug_e(e, "%s Error notified", self)
+            begin
+              @tour.res.send_error(@tour_id, HttpStatus::INTERNAL_SERVER_ERROR, nil, e)
+            rescue IOError => ex
+              BayLog.debug_e(ex)
+            end
+          end
+
+          def notify_eof
+            BayLog.debug("%s EOF", self)
+            begin
+              @tour.res.end_res_content(@tour_id)
+            rescue IOError => e
+              BayLog.debug_e(ex)
+            end
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_close
+            BayLog.debug("%s Close", self)
+          end
+
+          def check_timeout(duration_sec)
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/town.rb

@@ -9,21 +9,37 @@ module Baykit
         MATCH_TYPE_NOT_MATCHED = 2
         MATCH_TYPE_CLOSE = 3
 
-        #
-        # interface
-        #
-        #     String name();
-        #     City city();
-        #     String location();
-        #     String welcomeFile();
-        #     ArrayList<Club> clubs();
-        #     String reroute(String uri);
-        #     MatchType matches(String uri);
-        #     void checkAdmitted(Tour tour) throws HttpException;
-        #     String reroute(String uri);
-        #     MatchType matches(String uri);
-        #     void checkAdmitted(Tour tour) throws HttpException;
-        #
+        def name
+          raise NotImplementedError.new
+        end
+
+        def city
+          raise NotImplementedError.new
+        end
+
+        def location
+          raise NotImplementedError.new
+        end
+
+        def welcome_file
+          raise NotImplementedError.new
+        end
+
+        def clubs
+          raise NotImplementedError.new
+        end
+
+        def reroute(uri)
+          raise NotImplementedError.new
+        end
+
+        def matches(uri)
+          raise NotImplementedError.new
+        end
+
+        def check_admitted(tur)
+          raise NotImplementedError.new
+        end
       end
     end
   end

data/lib/baykit/bayserver/docker/trouble.rb

@@ -6,11 +6,23 @@ module Baykit
       module Trouble
         include Docker # implements
 
-        #
-        # interface
-        #
-        # find(status)
-        #
+        TROUBLE_METHOD_GUIDE = 1
+        TROUBLE_METHOD_TEXT = 2
+        TROUBLE_METHOD_REROUTE = 3
+
+        class Command
+          attr :method
+          attr :target
+
+          def initialize(method, target)
+            @method = method
+            @target = target
+          end
+        end
+
+        def find(status) Command
+          raise NotImplementedError.new
+        end
       end
     end
   end

data/lib/baykit/bayserver/docker/warp.rb

@@ -0,0 +1,34 @@
+require 'baykit/bayserver/docker/docker'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Warp # interface
+        include Docker # implements
+
+        def host
+          raise NotImplementedError.new
+        end
+
+        def port
+          raise NotImplementedError.new
+        end
+        def warp_base
+          raise NotImplementedError.new
+        end
+
+        def timeout_sec
+          raise NotImplementedError.new
+        end
+
+        def keep(warp_ship)
+          raise NotImplementedError.new
+        end
+
+        def on_end_ship(warp_ship)
+          raise NotImplementedError.new
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/mem_usage.rb

@@ -4,8 +4,8 @@ require 'baykit/bayserver/agent/lifecycle_listener'
 require 'baykit/bayserver/protocol/protocol_handler_store'
 require 'baykit/bayserver/protocol/packet_store'
 require 'baykit/bayserver/tours/tour_store'
-require 'baykit/bayserver/docker/base/inbound_ship_store'
-require 'baykit/bayserver/docker/warp/warp_docker'
+require 'baykit/bayserver/common/inbound_ship_store'
+require 'baykit/bayserver/docker/base/warp_base'
 
 require 'baykit/bayserver/util/string_util'
 
@@ -16,19 +16,19 @@ module Baykit
       include Baykit::BayServer::Agent
       include Baykit::BayServer::Protocol
       include Baykit::BayServer::Tours
-      include Baykit::BayServer::Docker::Warp
+      include Baykit::BayServer::Common
       include Baykit::BayServer::Docker::Base
       include Baykit::BayServer::Util
 
       class AgentListener
         include Baykit::BayServer::Agent::LifecycleListener
 
-        def add(agt)
-          MemUsage.mem_usages[agt.agent_id] = MemUsage.new(agt.agent_id);
+        def add(agt_id)
+          MemUsage.mem_usages[agt_id] = MemUsage.new(agt_id);
         end
 
-        def remove(agt)
-          MemUsage.mem_usages.delete(agt.agent_id)
+        def remove(agt_id)
+          MemUsage.mem_usages.delete(agt_id)
         end
       end
 
@@ -73,14 +73,14 @@ module Baykit
         end
 
         city.clubs().each do |club|
-          if club.kind_of?(WarpDocker)
+          if club.kind_of?(WarpBase)
             BayLog.info("%sClub(%s%s) Usage:", StringUtil.indent(indent), club, pname);
             club.get_ship_store(@agent_id).print_usage(indent+1)
           end
         end
         city.towns().each do |town|
           town.clubs().each do |club|
-            if club.kind_of?(WarpDocker)
+            if club.kind_of?(WarpBase)
               BayLog.info("%sClub(%s%s) Usage:", StringUtil.indent(indent), club, pname);
               club.get_ship_store(@agent_id).print_usage(indent+1)
             end

data/lib/baykit/bayserver/protocol/command_packer.rb

@@ -24,7 +24,7 @@ module Baykit
           pkt = @pkt_store.rent(cmd.type)
           begin
             cmd.pack(pkt)
-            @pkt_packer.post(sip.postman, pkt) do
+            @pkt_packer.post(sip, pkt) do
               @pkt_store.Return(pkt)
               if lisnr != nil
                 lisnr.call()
@@ -36,13 +36,6 @@ module Baykit
           end
         end
 
-        def flush(sip)
-          @pkt_packer.flush(sip.postman)
-        end
-
-        def end(sip)
-          @pkt_packer.end(sip.postman)
-        end
       end
     end
   end

data/lib/baykit/bayserver/protocol/packet_packer.rb

@@ -7,23 +7,19 @@ module Baykit
         def reset()
         end
 
-        def post(postman, pkt, &lisnr)
-          if postman == nil || pkt == nil || lisnr == nil
+        def post(sip, pkt, &lisnr)
+          if sip == nil || pkt == nil || lisnr == nil
             raise Sink.new()
           end
-          postman.post(pkt.buf[0, pkt.buf_len], nil, pkt) do
+          sip.transporter.req_write(
+            sip.rudder,
+            pkt.buf[0, pkt.buf_len],
+            nil,
+            pkt) do
             lisnr.call()
           end
         end
 
-        def flush(postman)
-          postman.flush()
-        end
-
-        def end(postman)
-          postman.post_end()
-        end
-
       end
     end
   end

data/lib/baykit/bayserver/protocol/packet_store.rb

@@ -15,15 +15,15 @@ module Baykit
         class AgentListener
           include Baykit::BayServer::Agent::LifecycleListener # implements
 
-          def add(agt)
+          def add(agt_id)
             PacketStore.proto_map.values().each do |ifo|
-             ifo.add_agent(agt.agent_id);
+             ifo.add_agent(agt_id);
             end
           end
 
-          def remove(agt)
+          def remove(agt_id)
             PacketStore.proto_map.values().each do |ifo|
-              ifo.remove_agent(agt.agent_id);
+              ifo.remove_agent(agt_id);
             end
           end
         end

data/lib/baykit/bayserver/protocol/protocol_handler.rb

@@ -12,22 +12,36 @@ module Baykit
         attr :packet_packer
         attr :command_unpacker
         attr :command_packer
-        attr :packet_store
+        attr :command_handler
         attr :server_mode
         attr_accessor :ship
 
+        def initialize(pkt_unpacker, pkt_packer, cmd_unpacker, cmd_packer, cmd_handler, svr_mode)
+          @packet_unpacker = pkt_unpacker
+          @packet_packer = pkt_packer
+          @command_unpacker = cmd_unpacker
+          @command_packer = cmd_packer
+          @command_handler  = cmd_handler
+          @server_mode = svr_mode
+        end
         def to_s()
           return ClassUtil.get_local_name(self.class) + " ship=" + ship.to_s
         end
 
+        def init(sip)
+          @ship = sip
+        end
+
         ##################################################
         # Implements Reusable
         ##################################################
         def reset()
-          @command_unpacker.reset()
-          @command_packer.reset()
-          @packet_unpacker.reset()
-          @packet_packer.reset()
+          @command_unpacker.reset
+          @command_packer.reset
+          @packet_unpacker.reset
+          @packet_packer.reset
+          @command_handler.reset
+          @ship = nil
         end
 
         ##################################################
@@ -35,21 +49,21 @@ module Baykit
         ##################################################
 
         def protocol()
-          raise NotImplementedError()
+          raise NotImplementedError.new
         end
 
         #
         # Get max of request data size (maybe not packet size)
         #
         def max_req_packet_data_size()
-          raise NotImplementedError()
+          raise NotImplementedError.new
         end
 
         #
         # Get max of response data size (maybe not packet size)
         #
         def max_res_packet_data_size()
-          raise NotImplementedError()
+          raise NotImplementedError.new
         end
 
         ##################################################
@@ -58,6 +72,10 @@ module Baykit
         def bytes_received(buf)
           return @packet_unpacker.bytes_received(buf)
         end
+
+        def post(cmd, &lis)
+          @command_packer.post(@ship, cmd, &lis)
+        end
       end
     end
   end

data/lib/baykit/bayserver/protocol/protocol_handler_store.rb

@@ -38,13 +38,13 @@ module Baykit
             @stores = {}
           end
 
-          def add_agent(agt)
-            store = PacketStore.get_store(@protocol, agt.agent_id);
-            @stores[agt.agent_id] = ProtocolHandlerStore.new(@protocol, @server_mode, @protocol_handler_factory, store);
+          def add_agent(agt_id)
+            store = PacketStore.get_store(@protocol, agt_id);
+            @stores[agt_id] = ProtocolHandlerStore.new(@protocol, @server_mode, @protocol_handler_factory, store);
           end
 
-          def remove_agent(agt)
-            @stores.delete(agt.agent_id);
+          def remove_agent(agt_id)
+            @stores.delete(agt_id);
           end
 
         end

data/lib/baykit/bayserver/rudders/io_rudder.rb

@@ -0,0 +1,62 @@
+require 'baykit/bayserver/rudders/rudder'
+
+module Baykit
+  module BayServer
+    module Rudders
+      class IORudder
+        include Rudder
+
+        attr :io
+        attr :non_blocking
+
+        def initialize(io)
+          @io = io
+        end
+
+        def to_s
+          return "IORudder:" + @io.to_s
+        end
+        def key
+          return @io
+        end
+
+        def set_non_blocking()
+          @non_blocking = true
+        end
+
+        def read(buf, len)
+          begin
+            if @non_blocking
+              buf = @io.read_nonblock(len, buf)
+            else
+              buf = @io.readpartial(len, buf)
+            end
+            if buf == nil
+              return 0
+            else
+              return buf.length
+            end
+          rescue EOFError => e
+            return 0
+          end
+        end
+
+        def write(buf)
+          if @non_blocking
+            return @io.write_nonblock(buf)
+          else
+            return @io.write(buf)
+          end
+        end
+
+        def close
+          @io.close()
+        end
+
+        def io
+          return @io
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/rudders/rudder.rb

@@ -0,0 +1,29 @@
+
+module Baykit
+  module BayServer
+    module Rudders
+      module Rudder # interface
+
+        def key
+          raise NotImplementedError.new
+        end
+
+        def set_non_blocking
+          raise NotImplementedError.new
+        end
+
+        def read(buf, len)
+          raise NotImplementedError.new
+        end
+
+        def write(buf)
+          raise NotImplementedError.new
+        end
+
+        def close
+          raise NotImplementedError.new
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/{watercraft → ships}/ship.rb

@@ -3,7 +3,7 @@ require 'baykit/bayserver/util/counter'
 
 module Baykit
   module BayServer
-    module WaterCraft
+    module Ships
       class Ship
         include Baykit::BayServer::Util::Reusable   # implements
 
@@ -23,11 +23,10 @@ module Baykit
 
         attr :object_id
         attr :ship_id
-        attr :agent
-        attr :postman
-        attr :socket
+        attr :agent_id
+        attr :rudder
+        attr :transporter
         attr :initialized
-        attr_accessor :protocol_handler
         attr_accessor :keeping
 
         def initialize()
@@ -35,67 +34,92 @@ module Baykit
           @ship_id = INVALID_SHIP_ID
         end
 
-        ######################################################
+        def init(agt_id, rd, tp)
+          if @initialized
+            raise Sink.new("Ship already initialized")
+          end
+          @ship_id = Ship.ship_id_counter.next
+          @agent_id = agt_id
+          @rudder = rd
+          @transporter = tp
+          @initialized = true
+          BayLog.debug("%s initialized", self)
+        end
+
+        #########################################
         # implements Reusable
-        ######################################################
+        #########################################
         def reset()
           BayLog.debug("%s reset", self)
 
           @initialized = false
-          @postman.reset()
-          @postman = nil    # for reloading certification
-          @agent = nil
+          @transporter = nil
+          @rudder = nil
+          @agent_id = -1
           @ship_id = INVALID_SHIP_ID
-          @socket = nil
-          @protocol_handler = nil
           @keeping = false
         end
 
 
-        ######################################################
+        #########################################
         # Other methods
-        ######################################################
+        #########################################
 
-        def init(skt, agt, postman)
-          if @initialized
-            raise Sink.new("Ship already initialized")
+        def id()
+          @ship_id
+        end
+
+        def check_ship_id(check_id)
+          if !@initialized
+            raise Sink.new("#{self} ship not initialized (might be returned ship): #{check_id}")
+          end
+          if check_id != SHIP_ID_NOCHECK && check_id != @ship_id
+            raise Sink.new("#{self} Invalid ship id (might be returned ship): #{check_id}")
           end
-          @ship_id = Ship.ship_id_counter.next
-          @agent = agt
-          @postman = postman
-          @socket = skt
-          @initialized = true
-          BayLog.debug("%s initialized", self)
         end
 
-        def set_protocol_handler(proto_hnd)
-          @protocol_handler = proto_hnd
-          proto_hnd.ship = self
-          #BayLog.debug("%s protocol handler is set", self)
+        def resume_read(check_id)
+          check_ship_id(check_id);
+          @transporter.req_read(@rudder)
         end
 
-        def id()
-          @ship_id
+        def post_close
+          @transporter.req_close(@rudder)
         end
 
-        def protocol()
-          return @protocol_handler == nil ? "unknown" : @protocol_handler.protocol
+        #########################################
+        # Abstract methods
+        #########################################
+        def notify_handshake_done(proto)
+          raise NotImplementedError.new
         end
 
+        def notify_connect()
+          raise NotImplementedError.new
+        end
 
+        def notify_read(buf)
+          raise NotImplementedError.new
+        end
 
-        def resume(check_id)
-          check_ship_id(check_id);
-          @postman.open_valve();
+        def notify_eof()
+          raise NotImplementedError.new
         end
 
-        def check_ship_id(check_id)
-          if !@initialized
-            raise Sink.new("#{self} ship not initialized (might be returned ship): #{check_id}")
-          end
-          if check_id != SHIP_ID_NOCHECK && check_id != @ship_id
-            raise Sink.new("#{self} Invalid ship id (might be returned ship): #{check_id}")
-          end
+        def notify_error(e)
+          raise NotImplementedError.new
+        end
+
+        def notify_protocol_error(e)
+          raise NotImplementedError.new
+        end
+
+        def notify_close
+          raise NotImplementedError.new
+        end
+
+        def check_timeout(duration_sec)
+          raise NotImplementedError.new
         end
       end
     end