bayserver-core 2.2.0

data/lib/baykit/bayserver/docker/base/inbound_ship.rb

@@ -0,0 +1,341 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/watercraft/ship'
+require 'baykit/bayserver/tours/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class InboundShip < Baykit::BayServer::WaterCraft::Ship
+
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Tours
+          include Baykit::BayServer::Util
+
+          # class variables
+          class << self
+            attr :err_counter
+          end
+          @err_counter = Counter.new()
+
+          MAX_TOURS = 128
+
+          attr :port_docker
+
+          attr :tour_store
+          attr_accessor :need_end
+          attr :socket_timeout_sec
+          attr :lock
+          attr :active_tours
+
+          def initialize()
+            super
+            @lock = Monitor.new()
+            @active_tours = []
+          end
+
+          def to_s
+            return "#{@agent} ship##{@ship_id}/#{@object_id}[#{protocol()}]"
+          end
+
+          def init_inbound(skt, agt, postman, port, proto_hnd)
+            self.init(skt, agt, postman)
+            @port_docker = port
+            @socket_timeout_sec = @port_docker.timeout_sec >= 0 ? @port_docker.timeout_sec : BayServer.harbor.socket_timeout_sec
+            @tour_store = TourStore.get_store(agt.agent_id)
+            set_protocol_handler(proto_hnd)
+          end
+
+          ######################################################
+          # Implements Reusable
+          ######################################################
+
+          def reset()
+            super
+            @lock.synchronize do
+              if !@active_tours.empty?
+                raise Sink.new("%s There are some running tours", self)
+              end
+            end
+            @need_end = false
+          end
+
+          ######################################################
+          # Other methods
+          ######################################################
+
+          def get_tour(tur_key)
+            tur = nil
+            store_key = InboundShip.uniq_key(@ship_id, tur_key)
+            @lock.synchronize do
+              tur = @tour_store.get(store_key)
+              if tur == nil
+                tur = @tour_store.rent(store_key, false)
+                if tur == nil
+                  return nil
+                end
+                tur.init(tur_key, self)
+                @active_tours.append(tur)
+              end
+            end
+            return tur
+          end
+
+          def get_error_tour
+            tur_key = InboundShip.err_counter.next()
+            store_key = InboundShip.uniq_key(@ship_id, -tur_key)
+            tur = @tour_store.rent(store_key, true)
+            tur.init(-tur_key, self)
+            @active_tours.append(tur)
+            return tur
+          end
+
+          def send_headers(check_id, tur)
+            check_ship_id(check_id)
+
+            if tur.zombie? || tur.aborted?
+              # Don't send peer any data
+              return
+            end
+
+            handled = false
+            if !tur.error_handling && tur.res.headers.status >= 400
+              trouble = BayServer.harbor.trouble
+              if trouble != nil
+                cmd = trouble.find(tur.res.headers.status)
+                if cmd != nil
+                  err_tour = get_error_tour
+                  err_tour.req.uri = cmd.target
+                  tur.req.headers.copy_to(err_tour.req.headers)
+                  tur.res.headers.copy_to(err_tour.res.headers)
+                  err_tour.req.remote_port = tur.req.remote_port
+                  err_tour.req.remote_address = tur.req.remote_address
+                  err_tour.req.server_address = tur.req.server_address
+                  err_tour.req.server_port = tur.req.server_port
+                  err_tour.req.server_name = tur.req.server_name
+                  err_tour.res.header_sent = tur.res.header_sent
+                  tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ZOMBIE)
+                  case cmd.method
+                  when :GUIDE
+                    err_tour.go
+                  when :TEXT
+                    @protocol_handler.send_headers(err_tour)
+                    data = cmd.target
+                    err_tour.res.send_content(Tour::TOUR_ID_NOCHECK, data, 0, data.length)
+                    err_tour.end_content(Tour::TOUR_ID_NOCHECK)
+                  when :REROUTE
+                    err_tour.res.send_http_exception(Tour::TOUR_ID_NOCHECK, HttpException.moved_temp(cmd.target))
+                  end
+                  handled = true
+                end
+              end
+            end
+            if !handled
+              @port_docker.additional_headers.each do |nv|
+                tur.res.headers.add(nv[0], nv[1])
+              end
+              begin
+                @protocol_handler.send_res_headers(tur)
+              rescue IOError => e
+                BayLog.debug_e(e, "%s abort: %s", tur, e)
+                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ABORTED)
+                raise e
+              end
+            end
+          end
+
+          def send_redirect(check_id, tur, status, location)
+            check_ship_id(check_id)
+
+            hdr = tur.res.headers
+            hdr.status = status
+            hdr.set(Headers::LOCATION, location)
+
+            body = "<H2>Document Moved.</H2><BR>" + "<A HREF=\"" + location + "\">" + location + "</A>"
+
+            send_error_content(check_id, tur, body)
+          end
+
+          def send_res_content(check_id, tur, bytes, ofs, len, &callback)
+
+            BayLog.debug("%s send_res_content bytes: %d", self, len)
+
+            check_ship_id(check_id)
+
+            if tur.zombie? || tur.aborted?
+              # Don't send peer any data
+              BayLog::debug("%s Aborted or zombie tour. do nothing: %s state=%s", self, tur, tur.state)
+              tur.change_state(check_id, TourState::ENDED)
+              if callback != nil
+                callback.call()
+              end
+              return
+            end
+
+            max_len = @protocol_handler.max_res_packet_data_size();
+            if len > max_len
+              send_res_content(Tour::TOUR_ID_NOCHECK, tur, bytes, ofs, max_len)
+              send_res_content(Tour::TOUR_ID_NOCHECK, tur, bytes, ofs + max_len, len - max_len, &callback)
+            else
+              begin
+                @protocol_handler.send_res_content(tur, bytes, ofs, len, &callback)
+              rescue IOError => e
+                BayLog.debug_e(e, "%s abort: %s", tur, e)
+                tur.change_state(Tour::TOUR_ID_NOCHECK, Tour::TourState::ABORTED)
+                raise e
+              end
+            end
+          end
+
+          def send_end_tour(chk_ship_id, chk_tour_id, tur, &callback)
+            @lock.synchronize do
+              check_ship_id(chk_ship_id)
+              BayLog.debug("%s sendEndTour: %s state=%s", self, tur, tur.state)
+
+              if tur.zombie? || tur.aborted?
+                # Don't send peer any data. Do nothing
+                BayLog.debug("%s Aborted or zombie tour. do nothing: %s state=%s", self, tur, tur.state)
+                tur.change_state(chk_tour_id, Tour::TourState::ENDED)
+                callback.call()
+              else
+                if !tur.valid?
+                  raise Sink.new("Tour is not valid")
+                end
+                keep_alive = false
+                if tur.req.headers.get_connection() == Headers::CONNECTION_KEEP_ALIVE
+                  keep_alive = true
+                  if keep_alive
+                    res_conn = tur.res.headers.get_connection()
+                    keep_alive = (res_conn == Headers::CONNECTION_KEEP_ALIVE) ||
+                      (res_conn == Headers::CONNECTION_UNKOWN)
+                  end
+                  if keep_alive
+                    if tur.res.headers.content_length() < 0
+                      keep_alive = false
+                    end
+                  end
+                end
+
+                tur.change_state(chk_tour_id, Tour::TourState::ENDED)
+
+                @protocol_handler.send_end_tour(tur, keep_alive, &callback)
+              end
+            end
+          end
+
+          def send_error(chk_id, tour, status, message, e)
+
+            check_ship_id(chk_id)
+
+            BayLog.info("%s send error: status=%d, message=%s ex=%s", self, status, message, e == nil ? "" : e.message)
+
+            if e != nil
+              BayLog.debug_e(e)
+            end
+
+            # Create body
+            str = HttpStatus.description(status)
+
+            # print status
+            body = StringUtil.alloc(8192)
+
+            body << "<h1>" << status.to_s << " " << str << "</h1>\r\n"
+
+            # print message
+            #if message != nil && BayLog.debug_mode?
+            #  body << message
+            #end
+
+            # print stack trace
+            #if e != nil && BayLog.debug_mode?
+            #  body << "<P><HR><P>\r\n"
+            #  body << "<pre>\r\n"
+            #  e.backtrace.each do |item|
+            #    body << item << "\r\n"
+            #  end
+            #  body << "</pre>"
+            #end
+
+            tour.res.headers.status = status
+            send_error_content(chk_id, tour, body)
+          end
+
+
+
+          def end_ship()
+            BayLog.debug("%s endShip", self)
+            @port_docker.return_protocol_handler(@agent, @protocol_handler)
+            @port_docker.return_ship(self)
+          end
+
+
+          def abort_tours()
+            return_list = []
+
+            # Abort tours
+            @active_tours.each do |tur|
+              if tur.valid?
+                BayLog.debug("%s is valid, abort it: stat=%s", tur, tur.state)
+                if tur.req.abort()
+                  return_list << tur
+                end
+              end
+            end
+
+            return_list.each do |tur|
+              return_tour(tur)
+            end
+          end
+
+          protected
+          def send_error_content(chk_id, tour, content)
+
+            #Get charset
+            charset = tour.res.charset
+
+            # Set content type
+            if StringUtil.set? charset
+              tour.res.headers.set_content_type("text/html charset=" + charset)
+            else
+              tour.res.headers.set_content_type("text/html")
+            end
+
+            if StringUtil.set? content
+              tour.res.headers.set_content_length(content.length)
+            end
+            send_headers(chk_id, tour)
+
+            if StringUtil.set? content
+              send_res_content(chk_id, tour, content, 0, content.length)
+            end
+          end
+
+
+          private
+
+          def self.uniq_key(sip_id, tur_key)
+            return sip_id << 32 | (tur_key & 0xffffffff);
+          end
+
+          public
+          def return_tour(tur)
+            BayLog.debug("%s Return tour: %s", self, tur)
+            @lock.synchronize do
+              if !@active_tours.include?(tur)
+                raise Sink.new("Tour is not in acive list: %s", tur);
+              end
+
+              tour_store.Return(InboundShip.uniq_key(@ship_id, tur.req.key))
+              @active_tours.delete(tur)
+
+              if @need_end && @active_tours.empty?
+                end_ship()
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/docker/base/inbound_ship_store.rb

@@ -0,0 +1,65 @@
+require 'baykit/bayserver/agent/grand_agent'
+
+require 'baykit/bayserver/docker/base/inbound_ship'
+require 'baykit/bayserver/docker/base/inbound_ship_store'
+
+require 'baykit/bayserver/util/object_store'
+require 'baykit/bayserver/util/string_util'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class InboundShipStore < Baykit::BayServer::Util::ObjectStore
+          include Baykit::BayServer::WaterCraft
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+
+          class AgentListener
+            include Baykit::BayServer::Agent::GrandAgent::GrandAgentLifecycleListener # implements
+
+            def add(agt)
+              InboundShipStore.stores[agt.agent_id] = InboundShipStore.new();
+            end
+
+            def remove(agt)
+              InboundShipStore.stores.delete(agt.agent_id);
+            end
+          end
+
+          class << self
+            #  Agent id => InboundShipStore
+            attr :stores
+          end
+          @stores = {}
+
+          def initialize()
+            super
+            @factory = -> { InboundShip.new() }
+          end
+
+          #
+          #  print memory usage
+          #
+          def print_usage(indent)
+            BayLog.info("%sInboundShipStore Usage:", StringUtil.indent(indent));
+            super(indent+1);
+          end
+
+
+          ######################################################
+          # class methods
+          ######################################################
+          def self.init()
+            GrandAgent.add_lifecycle_listener(AgentListener.new())
+          end
+
+          def self.get_store(agent_id)
+            return @stores[agent_id]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/base/port_base.rb

@@ -0,0 +1,228 @@
+require 'baykit/bayserver/protocol/protocol_handler_store'
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/util/object_store'
+require 'baykit/bayserver/util/object_factory'
+
+require 'baykit/bayserver/docker/port'
+require 'baykit/bayserver/docker/base/docker_base'
+require 'baykit/bayserver/docker/base/inbound_data_listener'
+require 'baykit/bayserver/docker/base/inbound_ship_store'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class PortBase < Baykit::BayServer::Docker::Base::DockerBase
+          include Baykit::BayServer::Docker::Port #implements
+
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Transporter
+          include Baykit::BayServer::Docker
+          include Baykit::BayServer::Docker::Base
+          include Baykit::BayServer::WaterCraft
+          include Baykit::BayServer::Protocol
+          include Baykit::BayServer::Util
+
+          attr :permission_list
+          attr :host
+          attr :port
+          attr :anchored
+          attr :additional_headers
+          attr :socket_path
+          attr :timeout_sec
+          attr :secure_docker
+          attr :cities
+
+          def initialize()
+            @permission_list = []
+            @timeout_sec = -1
+            @host = nil
+            @port = -1
+            @anchored = true
+            @additional_headers = []
+            @socket_path = nil
+            @secure_docker = nil
+            @cities = Cities.new()
+          end
+
+          def to_s()
+            return super + "[" + @port + "]"
+          end
+
+          ######################################################
+          # Abstract methods
+          ######################################################
+          def support_anchored()
+            raise NotImplementedError()
+          end
+
+          def support_unanchored()
+            raise NotImplementedError()
+          end
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            if StringUtil.empty?(elm.arg)
+              raise ConfigException.new(elm.file_name, elm.line_no, BayMessage.get(:CFG_INVALID_PORT_NAME, elm.name))
+            end
+
+            super
+
+            port_name = elm.arg.downcase()
+            if port_name.start_with?(":unix:")
+              # unix domain sokcet
+              @port = -1
+              @socket_path = elm.arg[6 .. -1]
+              @host = elm.arg
+            else
+              # TCP or UDP port
+              if port_name.start_with?(":tcp:")
+                # tcp server socket
+                @anchored = true
+                host_port = elm.arg[5 .. -1]
+              elsif port_name.start_with?(":udp:")
+                # udp server socket
+                @anchored = false
+                host_port = elm.arg[5 .. -1]
+              else
+                # default: tcp server socket
+                @anchored = true
+                host_port = elm.arg
+              end
+
+              begin
+                idx = host_port.index(':')
+                if idx != nil
+                  @host = host_port[0 .. idx]
+                  @port = host_port[idx+1 .. -1].to_i
+                else
+                  @host = nil
+                  @port = host_port.to_i
+                end
+              rescue => e
+                raise ConfigException.new(elm.file_name, elm.line_no, BayMessage.get(:CFG_INVALID_PORT_NAME, elm.name))
+              end
+
+              if @anchored
+                if !support_anchored()
+                  raise ConfigException.new(elm.file_name, elm.line_no, BayMessage.get(:CFG_TCP_NOT_SUPPORTED))
+                end
+              else
+                if !support_unanchored()
+                  raise ConfigException.new(elm.file_name, elm.line_no, BayMessage.get(:CFG_UDP_NOT_SUPPORTED))
+                end
+              end
+
+            end
+
+          end
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init_docker(dkr)
+            if dkr.kind_of? Permission
+              @permission_list.append(dkr)
+            elsif dkr.kind_of? City
+              @cities.add(dkr)
+            elsif dkr.kind_of? Secure
+              @secure_docker = dkr
+            else
+              return super
+            end
+            return true
+          end
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "timeout"
+              @timeout_sec = Integer(kv.value)
+
+            when "addheader"
+              idx = kv.value.index(':')
+              if idx == nil
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+
+              name = kv.value[0 .. idx].strip()
+              value = kv.value[idx+1 .. -1].strip()
+              @additional_headers << [name, value]
+
+            else
+              return super
+            end
+            return true
+          end
+
+          ######################################################
+          # implements Port
+          ######################################################
+          def address()
+            if @socket_path
+              #  Unix domain socket
+              return @socket_path
+            elsif @host == nil
+              return [@port, "0.0.0.0"]
+            else
+              return [@port, @host]
+            end
+          end
+
+          def secure()
+            return @secure_docker != nil
+          end
+
+          def check_admitted(skt)
+            @permission_list.each do |perm_dkr|
+              perm_dkr.socket_admitted(skt)
+            end
+          end
+
+          def find_city(name)
+            return @cities.find_city(name)
+          end
+
+          def new_transporter(agt, skt)
+            sip = PortBase.get_ship_store(agt).rent()
+            if secure()
+              tp = @secure_docker.create_transporter(IOUtil.get_sock_recv_buf_size(skt))
+            else
+              tp = PlainTransporter.new(true, IOUtil.get_sock_recv_buf_size(skt))
+            end
+
+            proto_hnd = PortBase.get_protocol_handler_store(protocol(), agt).rent()
+            sip.init_inbound(skt, agt, tp, self, proto_hnd)
+            tp.init(agt.non_blocking_handler, skt, InboundDataListener.new(sip))
+            return tp
+          end
+
+          def return_protocol_handler(agt, proto_hnd)
+            BayLog.debug("%s Return protocol handler: ", proto_hnd)
+            PortBase.get_protocol_handler_store(proto_hnd.protocol, agt).Return(proto_hnd)
+          end
+
+          def return_ship(sip)
+            BayLog.debug("%s end (return ship)", sip)
+            PortBase.get_ship_store(sip.agent).Return(sip)
+          end
+
+          def PortBase.get_ship_store(agt)
+            return InboundShipStore.get_store(agt.agent_id)
+          end
+
+          def PortBase.get_protocol_handler_store(proto, agt)
+            return ProtocolHandlerStore.get_store(proto, true, agt.agent_id)
+          end
+
+        end
+      end
+    end 
+  end 
+end 
+

data/lib/baykit/bayserver/docker/base/reroute_base.rb

@@ -0,0 +1,28 @@
+require 'baykit/bayserver/docker/base/docker_base'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class RerouteBase < Baykit::BayServer::Docker::Base::DockerBase
+          include Reroute # implements
+
+          include Baykit::BayServer::Bcf
+
+          def init(elm, parent)
+            name = elm.arg;
+            if name != "*"
+              raise ConfigException.new(elm.file_name, elm.line_no, "Invalid reroute name: %s", name)
+            end
+            super
+          end
+
+
+          def match(uri)
+            return true
+          end
+        end
+      end
+    end
+  end
+end