bayserver-core 2.2.0

data/lib/baykit/bayserver/http_exception.rb

@@ -0,0 +1,33 @@
+require 'baykit/bayserver/bay_exception'
+require 'baykit/bayserver/util/http_status'
+
+module Baykit
+  module BayServer
+
+    class HttpException < BayException
+      include Baykit::BayServer::Util
+
+      attr :status    # Http status
+      attr_accessor :location  # for 302
+
+      def initialize(status, fmt=nil, *args)
+        super(fmt, *args)
+        @status = status
+        if @status < 300 || @status >= 600
+          raise RuntimeError.new "IllegalArgument"
+        end
+      end
+
+      def message
+        "HTTP #{@status} #{super}"
+      end
+
+      def self.moved_temp(location)
+        e = HttpException.new(HttpStatus::MOVED_TEMPORARILY, location)
+        e.location = location
+        return e
+      end
+
+    end
+  end
+end

data/lib/baykit/bayserver/mem_usage.rb

@@ -0,0 +1,104 @@
+require 'baykit/bayserver/bayserver'
+require 'baykit/bayserver/agent/grand_agent'
+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/util/string_util'
+
+module Baykit
+  module BayServer
+    class MemUsage
+      include Baykit::BayServer
+      include Baykit::BayServer::Agent
+      include Baykit::BayServer::Protocol
+      include Baykit::BayServer::Tours
+      include Baykit::BayServer::Docker::Warp
+      include Baykit::BayServer::Docker::Base
+      include Baykit::BayServer::Util
+
+      class AgentListener
+        include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener
+
+        def add(agt)
+          MemUsage.mem_usages[agt.agent_id] = MemUsage.new(agt.agent_id);
+        end
+
+        def remove(agt)
+          MemUsage.mem_usages.delete(agt.agent_id)
+        end
+      end
+
+      class << self
+        attr :mem_usages
+      end
+      # Agent ID => MemUsage
+      @mem_usages = {}
+
+      attr :agent_id
+
+      def initialize(agt_id)
+        @agent_id = agt_id
+      end
+
+      def print_usage(indent)
+        InboundShipStore.get_store(@agent_id).print_usage(indent+1)
+        ProtocolHandlerStore.get_stores(@agent_id).each do |store|
+          store.print_usage(indent+1)
+        end
+        PacketStore.get_stores(@agent_id).each do |store|
+          store.print_usage(indent+1)
+        end
+        TourStore.get_store(@agent_id).print_usage(indent+1);
+        BayServer.cities.cities.each do |city|
+          print_city_usage(nil, city, indent)
+        end
+
+        BayServer.ports.each do |port|
+          port.cities.cities().each do |city|
+            print_city_usage(port, city, indent)
+          end
+        end
+      end
+
+
+      def print_city_usage(port, city, indent)
+        if port == nil
+          pname = ""
+        else
+          pname = "@#{port}"
+        end
+
+        city.clubs().each do |club|
+          if club.kind_of?(WarpDocker)
+            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)
+              BayLog.info("%sClub(%s%s) Usage:", StringUtil.indent(indent), club, pname);
+              club.get_ship_store(@agent_id).print_usage(indent+1)
+            end
+          end
+        end
+      end
+
+
+      ######################################################
+      # Class methods
+      ######################################################
+      def self.init()
+        GrandAgent.add_lifecycle_listener(AgentListener.new());
+      end
+
+      def self.get(agent_id)
+        return @mem_usages[agent_id]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Baykit
+  module BayServer
+    module Protocol
+      class Command
+
+        # abstract methods
+        #
+        # unpack(P packet)
+        # pack(P packet)
+        # handle(H handler)
+
+        attr :type
+
+        def initialize(type)
+          @type = type
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Baykit
+  module BayServer
+    module Protocol
+      module CommandHandler
+        include Baykit::BayServer::Util::Reusable   # implements
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'baykit/bayserver/util/data_consume_listener'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class CommandPacker
+        include Baykit::BayServer::Util::Reusable # implements
+
+        include Baykit::BayServer::Util
+
+        attr :pkt_packer
+        attr :pkt_store
+
+        def initialize(pkt_packer, store)
+          @pkt_packer = pkt_packer
+          @pkt_store = store
+        end
+
+        def reset()
+
+        end
+
+        def post(sip, cmd, &lisnr)
+          pkt = @pkt_store.rent(cmd.type)
+          begin
+            cmd.pack(pkt)
+            @pkt_packer.post(sip.postman, pkt) do
+              @pkt_store.Return(pkt)
+              if lisnr != nil
+                lisnr.call()
+              end
+            end
+          rescue IOError => e
+            @pkt_store.Return(pkt)
+            raise e
+          end
+        end
+
+        def flush(sip)
+          @pkt_packer.flush(sip.postman)
+        end
+
+        def end(sip)
+          @pkt_packer.end(sip.postman)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Baykit
+  module BayServer
+    module Protocol
+      class CommandUnPacker
+        include Baykit::BayServer::Util::Reusable # implements
+
+        # interface
+        #
+        # packet_received(pkt)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'baykit/bayserver/protocol/packet'
+require 'baykit/bayserver/protocol/packet_part_accessor'
+require 'baykit/bayserver/protocol/packet_packer'
+require 'baykit/bayserver/protocol/packet_unpacker'
+require 'baykit/bayserver/protocol/packet_store'
+require 'baykit/bayserver/protocol/packet_factory'
+require 'baykit/bayserver/protocol/command'
+require 'baykit/bayserver/protocol/command_packer'
+require 'baykit/bayserver/protocol/command_unpacker'
+require 'baykit/bayserver/protocol/command_handler'
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/protocol/protocol_handler'
+require 'baykit/bayserver/protocol/protocol_handler_factory'
+require 'baykit/bayserver/protocol/protocol_handler_store'
+

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

@@ -0,0 +1,63 @@
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/class_util'
+
+#
+# Packet format
+#   +---------------------------+
+#  +  Header(type, length etc) +
+#  +---------------------------+
+#  +  Data(payload data)       +
+#  +---------------------------+
+#
+module Baykit
+  module BayServer
+    module Protocol
+      class Packet
+        include Baykit::BayServer::Util
+        include Baykit::BayServer::Util::Reusable # implements
+
+        INITIAL_BUF_SIZE = 8192 * 4
+
+        attr :type
+        attr :buf
+        attr_accessor :buf_len
+        attr :header_len
+        attr :max_data_len
+
+        def initialize(type, header_len, max_data_len)
+          @type = type
+          @header_len = header_len
+          @max_data_len = max_data_len
+          @buf = StringUtil.alloc(INITIAL_BUF_SIZE)
+          reset
+        end
+
+        def reset
+          @buf.clear()
+          header_len.times do |i| @buf << 0 end
+          @buf_len = header_len
+        end
+
+        def data_len()
+          return @buf_len - @header_len
+        end
+
+        def expand
+          @buf = StringUtil.realloc(@buf, @buf.length * 2)
+        end
+
+        def new_header_accessor()
+          return PacketPartAccessor.new(self, 0, @header_len)
+        end
+
+        def new_data_accessor()
+          return PacketPartAccessor.new(self, @header_len, -1)
+        end
+
+        def to_s
+          return "pkt[#{ClassUtil.get_local_name(self.class)}(#{@type})]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Baykit
+  module BayServer
+    module Protocol
+      class PacketFactory
+
+        # abstract methods
+        #
+        # create_packet(type)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Baykit
+  module BayServer
+    module Protocol
+      class PacketPacker
+        include Baykit::BayServer::Util::Reusable # implements
+
+        def reset()
+        end
+
+        def post(postman, pkt, &lisnr)
+          if postman == nil || pkt == nil || lisnr == nil
+            raise Sink.new()
+          end
+          postman.post(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
+end

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

@@ -0,0 +1,122 @@
+require 'baykit/bayserver/sink'
+require 'baykit/bayserver/util/string_util'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class PacketPartAccessor
+        include Baykit::BayServer
+        include Baykit::BayServer::Util
+
+        attr :packet
+        attr :start
+        attr :max_len
+        attr :pos
+
+        def initialize(pkt, start, max_len)
+          @packet = pkt
+          @start = start
+          @max_len = max_len
+          @pos = 0
+        end
+
+        def put_byte(b)
+          buf = StringUtil.alloc(1)
+          buf << b
+          put_bytes(buf, 0, 1)
+        end
+
+        def put_bytes(buf, ofs=0, len=buf.length)
+          if len > 0
+            check_write(len)
+            #while(@start + @pos + len > @packet.buf.length)
+            #  packet.expand()
+            #end
+            begin
+              @packet.buf[@start + @pos, len] = buf[ofs, len]
+            rescue IndexError => e
+              raise IndexError.new("data exceeds packet size: len=#{len} pktlen=#{buf.length - @start}")
+            end
+
+            forward(len)
+          end
+        end
+
+        def put_short(val)
+          h = val >> 8 & 0xFF
+          l = val & 0xFF
+          buf = StringUtil.alloc(2)
+          buf << h << l
+          put_bytes(buf)
+        end
+
+        def put_int(val)
+          b1 = val >> 24 & 0xFF
+          b2 = val >> 16 & 0xFF
+          b3 = val >> 8 & 0xFF
+          b4 = val & 0xFF
+          buf = StringUtil.alloc(4)
+          buf << b1 << b2 << b3 << b4
+          put_bytes(buf)
+        end
+
+        def put_string(str)
+          if str == nil
+            raise Sink.new("nil")
+          end
+          put_bytes(StringUtil.to_bytes(str))
+        end
+
+        def get_byte
+          buf = StringUtil.alloc(1)
+          get_bytes(buf, 0, 1)
+          buf[0].codepoints[0]
+        end
+
+        def get_bytes(buf, ofs=0, len=buf.length)
+          if buf == nil
+            raise Sink.new("nil")
+          end
+
+          check_read(len)
+          buf[ofs, len] = @packet.buf[@start + @pos, len]
+          @pos += len
+        end
+
+        def get_short
+          h = get_byte
+          l = get_byte
+          h << 8 | l
+        end
+
+        def get_int
+          b1 = get_byte
+          b2 = get_byte
+          b3 = get_byte
+          b4 = get_byte
+          b1 << 24 | b2 << 16 | b3 << 8 | b4
+        end
+
+        def check_read(len)
+          max_len = (@max_len >= 0) ? @max_len : (@packet.buf_len - @start)
+          if @pos + len > max_len
+            raise Sink.new("Invalid array index")
+          end
+        end
+
+        def check_write(len)
+          if @max_len > 0 && @pos + len > @max_len
+            raise Sink.new("Buffer overflow")
+          end
+        end
+
+        def forward(len)
+          @pos += len
+          if @start + @pos > @packet.buf_len
+            @packet.buf_len = @start + @pos
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/util/object_store'
+require 'baykit/bayserver/protocol/packet_factory'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class PacketStore
+        include Baykit::BayServer::Util::Reusable # implements
+
+        include Baykit::BayServer::Agent
+        include Baykit::BayServer::Util
+
+        class AgentListener
+          include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener # implements
+
+          def add(agt)
+            PacketStore.proto_map.values().each do |ifo|
+             ifo.add_agent(agt.agent_id);
+            end
+          end
+
+          def remove(agt)
+            PacketStore.proto_map.values().each do |ifo|
+              ifo.remove_agent(agt.agent_id);
+            end
+          end
+        end
+
+
+        class ProtocolInfo
+          attr :protocol
+          attr :packet_factory
+
+          # Agent ID => PacketStore
+          attr :stores
+
+          def initialize(proto, pkt_factory)
+            @protocol = proto
+            @packet_factory = pkt_factory
+            @stores = {}
+          end
+
+          def add_agent(agt_id)
+            store = PacketStore.new(@protocol, @packet_factory);
+            @stores[agt_id] = store;
+          end
+
+          def remove_agent(agt_id)
+            @stores.delete(agt_id);
+          end
+
+        end
+
+        class << self
+          attr :proto_map
+        end
+        @proto_map = {}
+
+        attr :protocol
+        attr :store_map
+        attr :factory
+
+        def initialize(proto, factory)
+          @protocol = proto
+          @factory = factory
+          @store_map = {}
+        end
+
+        def reset
+          @store_map.values.each do |store|
+            store.reset
+          end
+        end
+
+        def rent(type)
+          if type == nil
+            raise RuntimeError.new("Nil argument")
+          end
+
+          store = @store_map[type]
+          if store == nil
+            store = ObjectStore.new(lambda do
+              if @factory.kind_of?(PacketFactory)
+                return @factory.create_packet(type)
+              else
+                # lambda
+                return @factory.call(type)
+              end
+            end)
+            @store_map[type] = store
+          end
+          return store.rent
+        end
+
+        def Return(pkt)
+          store = @store_map[pkt.type]
+          #puts "Return packet #{pkt}"
+          store.Return(pkt)
+        end
+
+
+        def print_usage(indent)
+          BayLog.info("%sPacketStore(%s) usage nTypes=%d", StringUtil.indent(indent), @protocol, @store_map.keys().size)
+          @store_map.keys.each do |type|
+            BayLog.info("%sType: %s", StringUtil.indent(indent+1), type)
+            @store_map[type].print_usage(indent+2)
+          end
+        end
+
+        ######################################################
+        # class methods
+        ######################################################
+        def self.init()
+          GrandAgent.add_lifecycle_listener(AgentListener.new())
+        end
+
+        def self.get_store(protocol, agent_id)
+          return @proto_map[protocol].stores[agent_id]
+        end
+
+        def self.register_protocol(protocol, factory)
+          if !@proto_map.include?(protocol)
+            @proto_map[protocol] = PacketStore::ProtocolInfo.new(protocol, factory)
+          end
+        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
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Protocol
+      class PacketUnPacker
+        include Baykit::BayServer::Util::Reusable # implements
+
+        #
+        # interface
+        #
+        # bytes_received(bytes)
+        #
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Baykit
+  module BayServer
+    module Protocol
+      class ProtocolException < StandardError
+        def initialize(fmt = nil, *args)
+          super(if fmt == nil
+                  nil
+                elsif args == nil
+                  sprintf("%s", fmt)
+                else
+                  sprintf(fmt, *args)
+                end)
+        end
+      end
+    end
+  end
+end