bayserver-core 2.2.0

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

@@ -0,0 +1,112 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/agent/transporter/data_listener'
+require 'baykit/bayserver/docker/warp/warp_ship'
+require 'baykit/bayserver/tours/tour'
+require 'baykit/bayserver/util/counter'
+require 'baykit/bayserver/util/http_status'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Warp
+        class WarpDataListener
+
+          include Baykit::BayServer::Agent::Transporter::DataListener   # implements
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Tours
+
+          attr :ship
+
+          def initialize(sip)
+            @ship = sip
+          end
+
+          def to_s()
+            return @ship.to_s
+          end
+
+          ######################################################
+          # Implements DataListener
+          ######################################################
+
+          def notify_handshake_done(protocol)
+            @ship.protocol_handler.verify_protocol(protocol)
+
+            #  Send pending packet
+            @ship.agent.non_blocking_handler.ask_to_write(@ship.socket)
+            NextSocketAction::CONTINUE
+          end
+
+          def notify_connect
+            @ship.connected = true
+            @ship.tour_map.values.each do |pair|
+              tur = pair[1]
+              tur.check_tour_id pair[0]
+              WarpData.get(tur).start
+            end
+            NextSocketAction::CONTINUE
+          end
+
+          def notify_read(buf, adr)
+            return @ship.protocol_handler.bytes_received(buf)
+          end
+
+          def notify_eof
+            BayLog.debug("%s EOF detected", self)
+
+            if @ship.tour_map.empty?
+              BayLog.debug("%s No warp tours. only close", self)
+              return NextSocketAction::CLOSE
+            end
+
+            @ship.tour_map.keys.each do |warp_id|
+              pair = @ship.tour_map[warp_id]
+              tur = pair[1]
+              tur.check_tour_id pair[0]
+
+              if !tur.res.header_sent
+                BayLog.error("%s Send ServiceUnavailable: tur=%s", self, tur);
+                tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "Server closed on reading headers")
+              else
+                # NOT treat EOF as Error
+                BayLog.debug("%s EOF is not an error: tur=%s", self, tur);
+                begin
+                  tur.res.end_content(Tour::TOUR_ID_NOCHECK)
+                rescue IOError => e
+                  BayLog::debug_e(e, "%s end content error: tur=%s", self, tur);
+                end
+              end
+            end
+
+            @ship.tour_map.clear()
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_protocol_error(err)
+            BayLog.error_e(err)
+            self.ship.notify_error_to_owner_tour(HttpStatus::SERVICE_UNAVAILABLE, err.message)
+            true
+          end
+
+          def check_timeout(duration_sec)
+            if @ship.is_timeout(duration_sec)
+              self.ship.notify_error_to_owner_tour(HttpStatus::GATEWAY_TIMEOUT, "#{self} server timeout")
+              true
+            else
+              false
+            end
+          end
+
+          def notify_close()
+            BayLog.debug("%s notifyClose", self)
+            self.ship.notify_error_to_owner_tour(HttpStatus::SERVICE_UNAVAILABLE, "#{self} server closed")
+            self.ship.end_ship()
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+require 'uri'
+
+require 'baykit/bayserver/agent/grand_agent'
+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'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Warp
+        class WarpDocker  < Baykit::BayServer::Docker::Base::ClubBase
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Docker::Warp
+
+          class AgentListener
+            include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener
+
+            attr :warp_docker
+
+            def initialize(dkr)
+              @warp_docker = dkr
+            end
+
+            def add(agt)
+              @warp_docker.stores[agt.agent_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
+            end
+          end
+
+          attr :scheme
+          attr :host
+          attr :port
+          attr :warp_base
+          attr :max_ships
+          attr :cur_ships
+          attr :host_addr
+          attr :timeout_sec
+          attr :tour_list
+          attr :lock
+
+          # Agent ID => WarpShipStore
+          attr :stores
+
+          ######################################################
+          # Abstract methods
+          ######################################################
+          #
+          #
+          #     public abstract boolean secure();
+          #     protected abstract String protocol();
+          #     protected abstract Transporter newTransporter(ShipAgent agent, SocketChannel ch);
+          #
+
+          def initialize
+            super
+            @scheme = nil
+            @host = nil
+            @port = 0
+            @warp_base = nil
+            @max_ships = -1
+            @cur_ships = 0
+            @host_addr = nil
+            @tour_list = []
+            @timeout_sec = -1 #  -1 means "Use harbor.socketTimeoutSec"
+            @stores = {}
+            @lock = Mutex.new
+          end
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init(elm, parent)
+            super
+
+            if @warp_base == nil
+              @warp_base = "/"
+            end
+
+            @host_addr = []
+            if @host && @host.start_with?(":unix:")
+              @host_addr << :UNIX
+              @host_addr <<  Socket.sockaddr_un(@host[6 .. -1])
+              @port = -1
+            else
+
+              if @port <= 0
+                @port = 80
+              end
+
+              @host_addr << :INET
+
+              begin
+                addrs = Addrinfo.getaddrinfo(@host, @port, nil, :STREAM)
+              rescue SocketError => e
+                BayLog.error_e(e)
+                raise ConfigException.new(elm.file_name, elm.line_no, "Invalid address: %s:%d", @host, @port)
+              end
+              inet4_addr = nil
+              inet6_addr = nil
+              if addrs
+                addrs.each do |adr|
+                  if adr.ipv4?
+                    inet4_addr = adr
+                  elsif adr.ipv6?
+                    inet6_addr = adr
+                  end
+                end
+              end
+
+              if inet4_addr
+                @host_addr << inet4_addr
+              elsif inet6_addr
+                @host_addr << inet6_addr
+              else
+                raise ConfigException.new(elm.file_name, elm.line_no, "Host not found: %s", @host)
+              end
+
+
+
+            end
+
+            GrandAgent.add_lifecycle_listener(AgentListener.new(self));
+
+            BayLog.info("WarpDocker[%s] host=%s port=%d adr=%s", @warp_base, @host, @port, @host_addr)
+          end
+
+          def init_key_val(kv)
+            case kv.key.downcase
+
+            when "destcity"
+              @host = kv.value
+
+            when "destport"
+              @port = kv.value.to_i
+
+            when "desttown"
+              @warp_base = kv.value
+              if !@warp_base.end_with?("/")
+                @warp_base += "/"
+              end
+
+            when "maxships"
+              @max_ships = kv.value.to_i
+
+            when "timeout"
+              @timeout_sec = kv.value.to_i
+
+            else
+              return super
+            end
+            return true
+          end
+
+          ######################################################
+          # Implements Club
+          ######################################################
+
+          def arrive(tur)
+            agt = tur.ship.agent
+            sto = get_ship_store(agt.agent_id)
+
+            wsip = sto.rent()
+            if wsip == nil
+              BayLog.warn("%s Busy!", self)
+              raise HttpException.new HttpStatus::INTERNAL_SERVER_ERROR, "WarpDocker busy"
+            end
+
+            begin
+              BayLog.trace("%s got from store", wsip)
+              need_connect = false
+
+              if !wsip.initialized
+                if @host_addr[0] == :UNIX
+                  skt = Socket.new(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+                else
+                  skt = Socket.new(@host_addr[1].ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM, 0)
+                end
+                skt.nonblock = true
+
+                tp = new_transporter(agt, skt)
+                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))
+                BayLog.debug("%s init warp ship", wsip)
+                BayLog.debug("%s Connect to %s:%d skt=%s", wsip, @host, @port, skt)
+
+                need_connect = true
+              end
+
+              @lock.synchronize do
+                @tour_list.append(tur)
+              end
+
+              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])
+              end
+
+            rescue SystemCallError => e
+              wsip.end_warp_tour(tur)
+              raise e
+            rescue HttpException => e
+              raise e
+            end
+
+          end
+
+
+
+          ######################################################
+          # Implements WarpDocker
+          ######################################################
+          def keep_ship(wsip)
+            BayLog.debug("%s keepShip: %s", self, wsip)
+            get_ship_store(wsip.agent.agent_id).keep(wsip)
+          end
+
+          def return_ship(wsip)
+            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)
+          end
+
+          ######################################################
+          # Other methods
+          ######################################################
+          def get_ship_store(agent_id)
+            return @stores[agent_id]
+          end
+
+          ######################################################
+          # private methods
+          ######################################################
+          private
+
+          def get_protocol_handler_store(agt_id)
+            return ProtocolHandlerStore.get_store(protocol(), false, agt_id)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+module Baykit
+  module BayServer
+    module Docker
+      module Warp
+        module WarpHandler # interface
+
+          def next_warp_id()
+            raise NotImplementedError()
+          end
+
+          def new_warp_data(warp_id)
+            raise NotImplementedError()
+          end
+
+          def post_warp_headers(tur)
+            raise NotImplementedError()
+          end
+
+          def post_warp_contents(tur, buf, start, len, &callback)
+            raise NotImplementedError()
+          end
+
+          def post_warp_end(tur)
+            raise NotImplementedError()
+          end
+
+          #
+          # Verify if protocol is allowed
+          #
+          def verify_protocol(protocol)
+            raise NotImplementedError()
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'baykit/bayserver/util/counter'
+require 'baykit/bayserver/util/http_status'
+require 'baykit/bayserver/docker/warp/warp_ship'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Warp
+        class WarpShip < Baykit::BayServer::WaterCraft::Ship
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::WaterCraft
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Util
+
+          attr :tour_map
+          attr :docker
+
+          attr_accessor :connected
+          attr :socket_timeout_sec
+          attr :lock
+
+
+          def initialize()
+            super
+            @docker = nil
+            @socket_timeout_sec = nil
+            @tour_map = {}
+            @lock = Mutex.new()
+            @connected = false
+          end
+
+          def to_s()
+            return "warp##{@ship_id}/#{@object_id}[#{protocol}]"
+          end
+
+          ######################################################
+          # Implements Reusable
+          ######################################################
+
+          def reset()
+            super
+            if !@tour_map.empty?
+              BayLog.error("BUG: Some tours is active: %s", @tour_map)
+            end
+            @connected = false
+          end
+
+
+          ######################################################
+          # Other methods
+          ######################################################
+          def init_warp(skt, agt, tp, dkr, proto_hnd)
+            init(skt, agt, tp)
+            @docker = dkr
+            @socket_timeout_sec = @docker.timeout_sec >= 0 ? @docker.timeout_sec : BayServer.harbor.socket_timeout_sec
+            set_protocol_handler(proto_hnd)
+          end
+
+          def warp_handler
+            return @protocol_handler
+          end
+
+          def start_warp_tour(tur)
+            w_hnd = warp_handler()
+            warp_id = w_hnd.next_warp_id()
+            wdat = w_hnd.new_warp_data(warp_id)
+            BayLog.debug("%s new warp tour related to %s", wdat, tur)
+            tur.req.set_content_handler(wdat)
+
+            BayLog.debug("%s start: warpId=%d", wdat, warp_id);
+            if @tour_map.key?(warp_id)
+              raise Sink.new("warpId exists")
+            end
+
+            @tour_map[warp_id] = [tur.id(), tur]
+            w_hnd.post_warp_headers(tur)
+
+            if @connected
+              BayLog.debug("%s is already connected. Start warp tour:%s", wdat, tur);
+              wdat.start
+            end
+          end
+
+          def end_warp_tour(tur)
+            wdat = WarpData.get(tur)
+            BayLog.debug("%s end: started=%s ended=%s", tur, wdat.started, wdat.ended)
+            @tour_map.delete wdat.warp_id
+            @docker.keep_ship(self)
+          end
+
+          def notify_service_unavailable(msg)
+            notify_error_to_owner_tour(HttpStatus::SERVICE_UNAVAILABLE, msg)
+          end
+
+          def get_tour(warp_id, must=true)
+            pair = @tour_map[warp_id]
+            if pair != nil
+              tur = pair[1]
+              tur.check_tour_id pair[0]
+              if !WarpData.get(tur).ended
+                return tur
+              end
+            end
+
+            if must
+              raise Sink.new("%s warp tours not found: id=%d", self, warp_id)
+            else
+              nil
+            end
+          end
+
+          def packet_unpacker
+            return @protocol_handler.packet_unpacker
+          end
+
+          def notify_error_to_owner_tour(status, msg)
+            @lock.synchronize do
+              @tour_map.keys.each do |warp_id|
+                tur = get_tour(warp_id)
+                BayLog.debug("%s send error to owner: %s running=%s", self, tur, tur.running?)
+                if tur.running?
+                  begin
+                    tur.res.send_error(Tour::TOUR_ID_NOCHECK, status, msg)
+                  rescue Exception => e
+                    BayLog.error_e(e)
+                  end
+                end
+              end
+              @tour_map.clear
+            end
+          end
+
+
+          def end_ship()
+            @docker.return_protocol_handler(@agent, @protocol_handler)
+            @docker.return_ship(self)
+          end
+
+          def abort(check_id)
+            check_ship_id(check_id)
+            @postman.abort
+          end
+
+          def is_timeout(duration)
+            if @keeping
+              # warp connection never timeout in keeping
+              timeout = false
+            elsif @socket_timeout_sec <= 0
+              timeout = false
+            else
+              timeout = duration >= @socket_timeout_sec
+            end
+
+            BayLog.debug("%s Warp check timeout: dur=%d, timeout=%s, keeping=%s limit=%d",
+                         self, duration, timeout, @keeping, @socket_timeout_sec)
+            return timeout
+          end
+
+          def inspect
+            to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'baykit/bayserver/protocol/packet_store'
+require 'baykit/bayserver/docker/warp/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Warp
+        class WarpShipStore < Baykit::BayServer::Util::ObjectStore
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Docker::Warp
+
+          attr :keep_list
+          attr :busy_list
+
+          attr :max_ships
+          attr :lock
+
+          def initialize(max_ships)
+            super()
+            @keep_list = []
+            @busy_list = []
+            @lock = Mutex.new
+            @max_ships = max_ships
+            @factory = -> { WarpShip.new() }
+          end
+
+          def to_s
+            return "warp_ship_store"
+          end
+
+          def rent()
+            if @max_ships > 0 && count() >= @max_ships
+              return nil
+            end
+
+            if @keep_list.empty?
+              BayLog.debug("rent from Object Store")
+
+              wsip = super()
+              if wsip == nil
+                return nil
+              end
+            else
+              BayLog.trace("rent from keep list: %s", @keep_list)
+              wsip = @keep_list.delete_at(@keep_list.length - 1)
+            end
+
+            if wsip == nil
+              raise Sink.new("BUG! ship is null")
+            end
+            if wsip.postman != nil && wsip.postman.zombie?
+              raise Sink("channel is zombie: %s", wsip)
+            end
+            @busy_list.append(wsip)
+
+            BayLog.trace(" rent keepList=%s busyList=%s", @keep_list, @busy_list)
+            return wsip
+          end
+
+          def keep(wsip)
+            BayLog.trace("keep: before keepList=%s busyList=%s", @keep_list, @busy_list)
+
+            if !@busy_list.delete(wsip)
+              BayLog.error("%s not in busy list", wsip)
+            end
+
+            @keep_list.append(wsip)
+
+            BayLog.trace("keep: after keepList=%s busyList=%s", @keep_list, @busy_list)
+          end
+
+          def Return(wsip)
+            BayLog.trace("Return: before keepList=%s busyList=%s", @keep_list, @busy_list)
+
+            removed_from_keep = @keep_list.delete(wsip)
+            removed_from_busy = @busy_list.delete(wsip)
+            if !removed_from_keep && !removed_from_busy
+              BayLog.error("%s not in both keep list and busy list", wsip)
+            end
+
+            super
+
+            BayLog.trace("Return: after keepList=%s busyList=%s", @keep_list, @busy_list)
+          end
+
+          def count()
+            @keep_list.length + @busy_list.length
+          end
+
+          def print_usage(indent)
+            BayLog.info("%sWarpShipStore Usage:", StringUtil.indent(indent))
+            BayLog.info("%skeepList: %d", StringUtil.indent(indent+1), @keep_list.length())
+            if BayLog.debug_mode?
+              @keep_list.each do |obj|
+                BayLog.debug("%s%s", StringUtil.indent(indent+1), obj)
+              end
+            end
+            BayLog.info("%sbusyList: %d", StringUtil.indent(indent+1), @busy_list.length())
+            if BayLog.debug_mode?
+              @busy_list.each do |obj|
+                BayLog.debug("%s%s", StringUtil.indent(indent+1), obj)
+              end
+            end
+            super
+          end
+        end
+      end
+    end
+  end
+end