bayserver-core 2.2.0

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

@@ -0,0 +1,64 @@
+require 'baykit/bayserver/util/class_util'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class ProtocolHandler
+        include Baykit::BayServer::Util::Reusable # implements
+
+        include Baykit::BayServer::Util
+
+        attr :packet_unpacker
+        attr :packet_packer
+        attr :command_unpacker
+        attr :command_packer
+        attr :packet_store
+        attr :server_mode
+        attr_accessor :ship
+
+        def to_s()
+          return ClassUtil.get_local_name(self.class) + " ship=" + ship.to_s
+        end
+
+        ##################################################
+        # Implements Reusable
+        ##################################################
+        def reset()
+          @command_unpacker.reset()
+          @command_packer.reset()
+          @packet_unpacker.reset()
+          @packet_packer.reset()
+        end
+
+        ##################################################
+        # Abstract methods
+        ##################################################
+
+        def protocol()
+          raise NotImplementedError()
+        end
+
+        #
+        # Get max of request data size (maybe not packet size)
+        #
+        def max_req_packet_data_size()
+          raise NotImplementedError()
+        end
+
+        #
+        # Get max of response data size (maybe not packet size)
+        #
+        def max_res_packet_data_size()
+          raise NotImplementedError()
+        end
+
+        ##################################################
+        # Other methods
+        ##################################################
+        def bytes_received(buf)
+          return @packet_unpacker.bytes_received(buf)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+
+module Baykit
+  module BayServer
+    module Protocol
+      module ProtocolHandlerFactory
+        #
+        # interface methods
+        #
+        # create_protocol_handler(pkt_store)
+        #
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/util/object_store'
+require 'baykit/bayserver/util/string_util'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class ProtocolHandlerStore < Baykit::BayServer::Util::ObjectStore
+        include Baykit::BayServer::Agent
+        include Baykit::BayServer::Util
+
+        class AgentListener
+          include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener # implements
+
+          def add(agt)
+            ProtocolHandlerStore.proto_map.values().each {|ifo| ifo.add_agent(agt) }
+          end
+
+          def remove(agt)
+            ProtocolHandlerStore.proto_map.values().each { |ifo| ifo.remove_agent(agt) }
+          end
+        end
+
+
+        class ProtocolInfo
+          attr :protocol
+          attr :server_mode
+          attr :protocol_handler_factory
+          attr :stores
+
+          def initialize(proto, svr_mode, proto_hnd_factory)
+            @protocol = proto
+            @server_mode = svr_mode
+            @protocol_handler_factory = proto_hnd_factory
+
+            # Agent ID => ProtocolHandlerStore
+            @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);
+          end
+
+          def remove_agent(agt)
+            @stores.delete(agt.agent_id);
+          end
+
+        end
+
+        class << self
+          attr :proto_map
+        end
+        @proto_map = {}
+
+
+        attr :protocol
+        attr :server_mode
+
+        def initialize(proto, svr_mode, proto_hnd_factory, pkt_store)
+          super()
+          @protocol = proto
+          @server_mode = svr_mode
+          @factory = -> do
+            return proto_hnd_factory.create_protocol_handler(pkt_store)
+          end
+        end
+
+        def print_usage(indent)
+          BayLog.info("%sProtocolHandlerStore(%s%s) Usage:", StringUtil.indent(indent), @protocol, @server_mode ? "s" : "c")
+          super(indent+1)
+        end
+
+        ######################################################
+        # class methods
+        ######################################################
+        def self.init()
+          GrandAgent.add_lifecycle_listener(AgentListener.new())
+        end
+
+        def self.get_store(protocol, svr_mode, agent_id)
+          return @proto_map[construct_protocol(protocol, svr_mode)].stores[agent_id]
+        end
+
+        def self.get_stores(agent_id)
+          store_list = []
+          @proto_map.values.each do |ifo|
+            store_list.append(ifo.stores[agent_id])
+          end
+          return store_list
+        end
+
+        def self.register_protocol(protocol, svr_mode, proto_hnd_factory)
+          if !@proto_map.include?(construct_protocol(protocol, svr_mode))
+            @proto_map[construct_protocol(protocol, svr_mode)] = ProtocolInfo.new(protocol, svr_mode, proto_hnd_factory)
+          end
+        end
+
+        def self.construct_protocol(protocol, svr_mode)
+          if(svr_mode)
+            return protocol + "-s"
+          else
+            return protocol + "-c"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/sink.rb

@@ -0,0 +1,22 @@
+#
+#  Ship sinks!!
+#   Exception thrown by some bugs
+#
+
+module Baykit
+  module BayServer
+    class Sink < StandardError
+
+      def initialize(fmt = nil, *args)
+        super(if fmt == nil
+                ""
+              elsif args == nil
+                sprintf("%s", fmt)
+              else
+                sprintf(fmt, *args)
+              end + "(>_<)")
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/taxi/taxi.rb

@@ -0,0 +1,38 @@
+require 'baykit/bayserver/util/counter'
+module Baykit
+  module BayServer
+    module Taxi
+      class Taxi
+        include Baykit::BayServer::Util
+        #
+        # abstract method
+        #
+        # depart()
+        #
+
+        class << self
+          attr :taxi_id_counter
+        end
+        @taxi_id_counter = Counter.new()
+
+        attr :taxi_id;
+
+        def initialize
+          @taxi_id = Taxi.taxi_id_counter.next()
+        end
+
+        def to_s()
+          return "Taxi##{@taxi_id}"
+        end
+
+        def run()
+          BayLog.trace("%s Start taxi on: %s", self, Thread.current.name);
+          self.depart();
+          BayLog.trace("%s End taxi on: %s", self, Thread.current.name);
+        end
+
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/taxi/taxi_runner.rb

@@ -0,0 +1,31 @@
+require 'baykit/bayserver/util/executor_service'
+
+module Baykit
+  module BayServer
+    module Taxi
+      class TaxiRunner
+        include Baykit::BayServer::Util
+
+        # define class instance accessor
+        class << self
+          attr :exe
+        end
+
+        def TaxiRunner.init(num_agents)
+          @exe = ExecutorService.new("TaxiRunner", num_agents)
+        end
+
+        def TaxiRunner.post(taxi)
+          begin
+            @exe.submit(taxi)
+            return true
+          rescue => e
+            BayLog.error_e(e)
+            return false
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/tours/content_consume_listener.rb

@@ -0,0 +1,20 @@
+
+module Baykit
+  module BayServer
+    module Tours
+
+      module ContentConsumeListener
+        # interface
+        #
+        #         void contentConsumed(int len, boolean resume);
+        #
+
+        DEV_NULL = Proc.new do
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/baykit/bayserver/tours/package.rb

@@ -0,0 +1,4 @@
+require 'baykit/bayserver/tours/tour'
+require 'baykit/bayserver/tours/tour_req'
+require 'baykit/bayserver/tours/tour_res'
+require 'baykit/bayserver/tours/tour_store'

data/lib/baykit/bayserver/tours/read_file_taxi.rb

@@ -0,0 +1,102 @@
+require 'baykit/bayserver/taxi/taxi'
+require 'baykit/bayserver/taxi/taxi_runner'
+require 'baykit/bayserver/agent/next_socket_action'
+
+require 'baykit/bayserver/util/valve'
+require 'baykit/bayserver/util/string_util'
+
+
+module Baykit
+  module BayServer
+    module Tours
+      class ReadFileTaxi < Baykit::BayServer::Taxi::Taxi
+        include Baykit::BayServer::Util::Valve #implements
+
+        include Baykit::BayServer::Agent
+        include Baykit::BayServer::Taxi
+        include Baykit::BayServer::Util
+
+        attr :infile
+        attr :ch_valid
+        attr :data_listener
+        attr :buf
+        attr :buf_size
+        attr :running
+        attr :lock
+
+        def initialize(buf_size)
+          super()
+          @buf_size = buf_size
+          @buf = StringUtil.alloc(buf_size)
+          @lock = Monitor.new()
+        end
+
+        def to_s()
+          return super.to_s() + " " + @data_listener.to_s()
+        end
+
+        def init(infile, data_listener)
+          @data_listener = data_listener
+          @infile = infile
+          @ch_valid = true
+        end
+
+        ######################################################
+        # implements Valve
+        ######################################################
+
+        def open_valve()
+          @lock.synchronize do
+            next_run()
+          end
+        end
+
+        ######################################################
+        # implements Taxi
+        ######################################################
+
+        def depart()
+          @lock.synchronize do
+            begin
+              @buf.clear()
+              @infile.read(@buf_size, @buf)
+
+              if @buf.length == 0
+                @data_listener.notify_eof()
+                close()
+                return
+              end
+
+              act = @data_listener.notify_read(@buf, nil)
+
+              @running = false
+              if act == NextSocketAction::CONTINUE
+                next_run()
+              end
+
+            rescue Exception => e
+              BayLog.error_e(e)
+              close()
+            end
+          end
+        end
+
+
+        def next_run()
+          if @running
+            # If running, not posted because next run exists
+            return
+          end
+          @running = true
+          TaxiRunner.post(self)
+        end
+
+        def close()
+          @ch_valid = false
+          @infile.close()
+          @data_listener.notify_close()
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/tours/req_content_handler.rb

@@ -0,0 +1,37 @@
+module Baykit
+  module BayServer
+    module Tours
+
+      module ReqContentHandler
+        #
+        # interface
+        #
+        #         void onReadContent(Tour tur, byte[] buf, int start, int len) throws IOException;
+        #         void onEndContent(Tour tur) throws IOException, HttpException;
+        #         void onAbort(Tour tur);
+        #
+
+        #DEV_NULL = nil
+      end
+
+      class DevNullReqContentHandler
+        include ReqContentHandler  # implements
+        def on_read_content(tur, buf, start, len)
+        end
+
+        def on_end_content(tur)
+        end
+
+        def on_abort(tur)
+          return false
+        end
+      end
+
+      module ReqContentHandler
+        DEV_NULL = DevNullReqContentHandler.new()
+      end
+    end
+  end
+end
+
+

data/lib/baykit/bayserver/tours/send_file_train.rb

@@ -0,0 +1,65 @@
+require 'baykit/bayserver/train/train'
+
+require 'baykit/bayserver/tours/tour'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/http_status'
+
+
+module Baykit
+  module BayServer
+    module Tours
+      class SendFileTrain < Baykit::BayServer::Train::Train
+
+        include Baykit::BayServer::Util
+
+        attr :file
+
+        def initialize(tur, file)
+          super(tur)
+          @file = file
+        end
+
+        ######################################################
+        # implements Train
+        ######################################################
+
+        def run()
+
+          @tour.res.set_consume_listener do |len, resume| end
+
+          size = @tour.ship.protocol_handler.max_packet_data_size
+          buf = StringUtil.alloc(size)
+          File.open(file, "r") do |fd|
+            begin
+              while true
+
+                while !@tour.res.available
+                  sleep(0.1)
+                end
+
+                begin
+                  fd.sysread(size, buf);
+                rescue EOFError => e
+                  break
+                rescue Exception => e
+                  @tour.res.send_error(@tour_id, HttpStatus::INTERNAL_SERVER_ERROR, e)
+                  break
+                end
+
+                @tour.res.send_content(@tour_id, buf, 0, buf.length);
+
+                while !@tour.res.available
+                  sleep(0.1)
+                end
+              end
+
+              @tour.res.end_content(@tour_id)
+            rescue Exception => e
+              BayLog.error_e(e);
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/tours/send_file_yacht.rb

@@ -0,0 +1,93 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/yacht'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Tours
+      class SendFileYacht < Baykit::BayServer::WaterCraft::Yacht
+
+        include Baykit::BayServer::Agent
+        include Baykit::BayServer::Util
+
+        attr :tour
+        attr :tour_id
+
+        attr :file_name
+        attr :file_len
+        attr :file_wrote_len
+
+        def initialize
+          super
+          reset()
+        end
+
+        def to_s()
+          return "filyt##{@yacht_id}/#{@object_id} tour=#{@tour} id=#{@tour_id}";
+        end
+
+        ######################################################
+        # implements Reusable
+        ######################################################
+
+        def reset()
+          @file_wrote_len = 0
+          @file_len = 0
+          @tour = nil
+          @tour_id = 0
+        end
+
+        ######################################################
+        # implements Yacht
+        ######################################################
+
+        def notify_read(buf, adr)
+          @file_wrote_len += buf.length
+          BayLog.trace("%s read file %d bytes: total=%d/%d", self, buf.length, @file_wrote_len, @file_len)
+          available = @tour.res.send_content(@tour_id, buf, 0, buf.length)
+
+          if available
+            return NextSocketAction::CONTINUE;
+          else
+            return NextSocketAction::SUSPEND;
+          end
+
+        end
+
+        def notify_eof()
+          BayLog.trace("%s EOF(^o^) %s", self, @file_name)
+          @tour.res.end_content(@tour_id)
+          return NextSocketAction::CLOSE
+        end
+
+        def notify_close()
+          BayLog.trace("File closed: %s", @file_name)
+        end
+
+        def check_timeout(duration)
+          BayLog.trace("Check timeout: %s", @file_name)
+        end
+
+        ######################################################
+        # Custom methods
+        ######################################################
+
+        def init(tur, file_name, tp)
+          init_yacht()
+          @tour = tur
+          @tour_id = tur.id()
+          @file_name = file_name
+          @file_len = File.size(file_name)
+          #file = File.open(file_name, "rb")
+          tur.res.set_consume_listener do |len, resume|
+            if resume
+              tp.open_valve();
+            end
+          end
+        end
+      end
+    end
+  end
+end
+