bayserver-core 2.2.0

data/lib/baykit/bayserver/docker/built_in/built_in_city_docker.rb

@@ -0,0 +1,303 @@
+require 'cgi'
+require 'baykit/bayserver/config_exception'
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/docker/package'
+require 'baykit/bayserver/docker/send_file/send_file_docker'
+require 'baykit/bayserver/docker/built_in/built_in_town_docker'
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/url_decoder'
+require 'baykit/bayserver/tours/tour'
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+        class BuiltInCityDocker < Baykit::BayServer::Docker::Base::DockerBase
+          include Baykit::BayServer::Docker::City  # implements
+
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Docker
+          include Baykit::BayServer::Docker::SendFile
+          include Baykit::BayServer::Docker::BuiltIn
+          include Baykit::BayServer::Agent
+
+          class  ClubMatchInfo
+            attr_accessor :club
+            attr_accessor :script_name
+            attr_accessor :path_info
+
+            def initialize
+              @club = nil
+              @script_name = nil
+              @path_info = nil
+            end
+          end
+
+          class MatchInfo
+            attr_accessor :town
+            attr_accessor :club_match
+            attr_accessor :query_string
+            attr_accessor :redirect_uri
+            attr_accessor :rewritten_uri
+          end
+
+          attr :towns
+          attr :default_town
+
+          attr :clubs
+          attr :default_club
+
+          attr :log_list
+          attr :permission_list
+
+          attr :trouble
+          attr :name
+
+          def initialize()
+            @towns = []
+            @clubs = []
+            @log_list = []
+            @permission_list = []
+          end
+
+          def to_s
+            "City[#{@name}]"
+          end
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            super
+
+            @name = elm.arg
+            @towns.sort! { |dkr1, dkr2| dkr2.name.length <=> dkr1.name.length }
+
+            @towns.each do |t|
+              BayLog.debug(BayMessage.get(:MSG_SETTING_UP_TOWN, t.name, t.location))
+            end
+
+            @default_town = BuiltInTownDocker.new
+            @default_club = SendFileDocker.new
+          end
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init_docker(dkr)
+            if dkr.kind_of?(Baykit::BayServer::Docker::Town)
+              @towns << dkr
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Club)
+              @clubs << dkr
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Log)
+              @log_list << dkr
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Permission)
+              @permission_list << dkr
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Trouble)
+              @trouble = dkr
+            else
+              return false
+            end
+            return true
+          end
+
+          def enter(tur)
+            BayLog.debug("%s City[%s] Request URI: %s", tur, @name, tur.req.uri)
+
+            tur.city = self
+            @permission_list.each do |p|
+              p.tour_admitted(tur)
+            end
+
+            match_info = get_town_and_club(tur.req.uri)
+            if match_info == nil
+              raise HttpException.new(HttpStatus::NOT_FOUND, tur.req.uri)
+            end
+
+            match_info.town.tour_admitted(tur)
+
+            if match_info.redirect_uri != nil
+              raise HttpException.moved_temp(match_info.redirect_uri)
+            else
+              BayLog.debug("%s Town[%s] Club[%s]", tur, match_info.town.name(), match_info.club_match.club)
+
+              tur.req.query_string = match_info.query_string
+              tur.req.script_name = match_info.club_match.script_name
+
+              if StringUtil.set?(match_info.club_match.club.charset)
+                tur.req.charset = match_info.club_match.club.charset
+                tur.res.charset = match_info.club_match.club.charset
+              else
+                tur.req.charset = BayServer.harbor.charset
+                tur.res.charset = BayServer.harbor.charset
+              end
+
+              tur.req.path_info = match_info.club_match.path_info
+              if StringUtil.set?(tur.req.path_info) && match_info.club_match.club.decode_path_info
+                tur.req.path_info = CGI.unescape(tur.req.path_info, Encoding::ASCII_8BIT)
+              end
+
+              if match_info.rewritten_uri
+                tur.req.rewritten_uri = match_info.rewritten_uri # URI is rewritten
+              end
+
+              clb = match_info.club_match.club
+              tur.town = match_info.town
+              tur.club = clb
+              clb.arrive(tur)
+            end
+          end
+
+          def log(tur)
+            @log_list.each do |dkr|
+              begin
+                dkr.log(tur)
+              rescue => e
+                BayLog.error_e(e)
+              end
+            end
+          end
+
+          private
+          def club_maches(club_list, rel_uri, town_name)
+
+            cmi = ClubMatchInfo.new()
+            any_club = nil
+
+            club_list.each do |clb|
+              if clb.file_name == "*" && clb.extension == nil
+                # Ignore any match club
+                any_club = clb
+                break
+              end
+            end
+
+            # search for club
+            rel_script_name = ""
+            catch(:loop) do
+              rel_uri.split("/").each do |fname|
+                if rel_script_name != ""
+                  rel_script_name += "/";
+                end
+                rel_script_name += fname
+
+                club_list.each do |clb|
+                  if clb == any_club
+                    # Ignore any match club
+                    next
+                  end
+
+                  if clb.matches(fname)
+                    cmi.club = clb;
+                    throw :loop
+                  end
+                end
+              end
+            end
+
+            if cmi.club == nil && any_club != nil
+              cmi.club = any_club
+            end
+
+            if cmi.club == nil
+              return nil
+            end
+
+            if town_name == "/" && rel_script_name == ""
+              cmi.script_name = "/"
+              cmi.path_info = nil
+            else
+              cmi.script_name = town_name + rel_script_name
+              if rel_script_name.length == rel_uri.length
+                cmi.path_info = nil
+              else
+                cmi.path_info = rel_uri[rel_script_name.length .. -1]
+              end
+            end
+
+            return cmi
+          end
+
+          def get_town_and_club(req_uri)
+            if req_uri == nil
+              raise RuntimeError.new("Req uri is nil")
+            end
+            mi = MatchInfo.new()
+
+            uri = req_uri
+            pos = uri.index('?')
+            if pos != nil
+              mi.query_string = uri[pos + 1 .. -1]
+              uri = uri[0, pos]
+            end
+
+            @towns.each do |t|
+              mtype = t.matches(uri)
+              if mtype == Baykit::BayServer::Docker::Town::MATCH_TYPE_NOT_MATCHED
+                next
+              end
+
+              # town matched
+              mi.town = t
+              if mtype == Baykit::BayServer::Docker::Town::MATCH_TYPE_CLOSE
+                mi.redirect_uri = uri + "/"
+                if mi.query_string != nil
+                  mi.redirect_uri += mi.query_string
+                end
+                return mi
+              end
+
+              org_uri = uri
+              uri = t.reroute(uri)
+              if uri != org_uri
+                mi.rewritten_uri = uri
+              end
+
+              rel = uri[t.name.length .. -1]
+
+              mi.club_match = club_maches(t.clubs, rel, t.name)
+              if mi.club_match == nil
+                mi.club_match = club_maches(@clubs, rel, t.name)
+              end
+
+              if mi.club_match == nil
+                # check index file
+                if uri.end_with?("/") && !StringUtil.empty?(t.welcome)
+
+                  index_uri = uri + t.welcome
+                  rel_uri = rel + t.welcome
+                  index_location = File.join(t.location, rel_uri)
+                  if File.file?(index_location)
+                    if mi.query_string != nil
+                      index_uri += "?" + mi.query_string
+                    end
+
+                    m2 = get_town_and_club(index_uri)
+                    if m2 != nil
+                      # matched
+                      m2.rewritten_uri = index_uri
+                      return m2
+                    end
+                  end
+                end
+
+                # default club matches
+                mi.club_match = ClubMatchInfo.new()
+                mi.club_match.club = @default_club
+                mi.club_match.script_name = nil
+                mi.club_match.path_info = nil
+              end
+              return mi
+            end
+
+            return nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/built_in/built_in_harbor_docker.rb

@@ -0,0 +1,226 @@
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/docker/harbor'
+require 'baykit/bayserver/docker/base/docker_base'
+require 'baykit/bayserver/constants'
+require 'baykit/bayserver/config_exception'
+
+require 'baykit/bayserver/util/groups'
+require 'baykit/bayserver/util/sys_util'
+
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+
+        class BuiltInHarborDocker < Baykit::BayServer::Docker::Base::DockerBase
+          include Baykit::BayServer::Docker::Harbor # implements
+
+          include Baykit::BayServer
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Constants
+
+          DEFAULT_MAX_SHIPS = 256
+          DEFAULT_SHIP_AGENTS = 0
+          DEFAULT_TRAIN_RUNNERS = 8
+          DEFAULT_TAXI_RUNNERS = 8
+          DEFAULT_WAIT_TIMEOUT_SEC = 120
+          DEFAULT_KEEP_TIMEOUT_SEC = 20
+          DEFAULT_TOUR_BUFFER_SIZE = 1024 * 1024;  # 1M
+          DEFAULT_TRACE_HEADER = false
+          DEFAULT_CHARSET = "UTF-8"
+          DEFAULT_CONTROL_PORT = -1
+          DEFAULT_MULTI_CORE = true
+          DEFAULT_GZIP_COMP = false
+          DEFAULT_FILE_SEND_METHOD = FILE_SEND_METHOD_TAXI
+          DEFAULT_PID_FILE = "bayserver.pid"
+
+          # Default charset
+          attr :charset
+
+          # Default locale
+          attr :locale
+
+          # Number of grand agents
+          attr :grand_agents
+
+          # Number of train runners
+          attr :train_runners
+
+          # Number of taxi runners
+          attr :taxi_runners
+
+          # Max count of watercraft
+          attr :max_ships
+
+          # Socket timeout in seconds
+          attr :socket_timeout_sec
+
+          # Keep-Alive timeout in seconds
+          attr :keep_timeout_sec
+
+          # Internal buffer size of Tour
+          attr :tour_buffer_size
+
+          # Trace req/res header flag
+          attr :trace_header
+
+          # Trouble docker
+          attr :trouble
+
+          # Auth groups
+          attr :groups
+
+          # File name to redirect stdout/stderr
+          attr :redirect_file
+
+          # Gzip compression flag
+          attr :gzip_comp
+
+          # Port number of signal agent
+          attr :control_port
+
+          # Multi core flag
+          attr :multi_core
+
+          # Method to send file
+          attr :file_send_method
+
+          # PID file name
+          attr :pid_file
+
+
+          def initialize
+            @grand_agents = DEFAULT_SHIP_AGENTS
+            @train_runners = DEFAULT_TRAIN_RUNNERS
+            @taxi_runners = DEFAULT_TAXI_RUNNERS
+            @max_ships = DEFAULT_MAX_SHIPS
+            @groups = Groups.new
+            @socket_timeout_sec = DEFAULT_WAIT_TIMEOUT_SEC
+            @keep_timeout_sec = DEFAULT_KEEP_TIMEOUT_SEC
+            @tour_buffer_size = DEFAULT_TOUR_BUFFER_SIZE
+            @trace_header = DEFAULT_TRACE_HEADER
+            @charset = DEFAULT_CHARSET
+            @control_port = DEFAULT_CONTROL_PORT
+            @multi_core = DEFAULT_MULTI_CORE
+            @gzip_comp = DEFAULT_GZIP_COMP
+            @file_send_method = DEFAULT_FILE_SEND_METHOD
+            @pid_file = DEFAULT_PID_FILE
+          end
+
+          ######################
+          # Implements Docker
+          ######################
+          def init(bcf, parent)
+            super
+
+            if @grand_agents <= 0
+              @grand_agents = SysUtil.processor_count()
+            end
+
+            if @train_runners <= 0
+              @train_runners = 1
+            end
+
+            if @max_ships < DEFAULT_MAX_SHIPS
+              @max_ships = DEFAULT_MAX_SHIPS
+              BayLog.warn(BayMessage.get(:CFG_MAX_SHIPS_IS_TO_SMALL, @max_ships))
+            end
+
+            if @file_send_method == FILE_SEND_METHOD_SELECT and !SysUtil.support_select_file()
+              BayLog.warn(BayMessage.get(:CFG_FILE_SEND_METHOD_SELECT_NOT_SUPPORTED))
+              @file_send_method = FILE_SEND_METHOD_TAXI
+            end
+
+            if @file_send_method == FILE_SEND_METHOD_SPIN and !SysUtil.support_nonblock_file_read()
+              BayLog.warn(BayMessage.get(:CFG_FILE_SEND_METHOD_SPIN_NOT_SUPPORTED))
+              @file_send_method = FILE_SEND_METHOD_TAXI
+            end
+
+
+          end
+
+          #######################
+          # Implements DockerBase
+          #######################
+
+          def init_docker(dkr)
+            if dkr.instance_of?(Trouble)
+              @trouble = dkr
+            else
+              return super
+            end
+            return true
+          end
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "loglevel"
+              BayLog.set_log_level(kv.value)
+            when "charset"
+              @charset = kv.value
+            when "locale"
+              @locale = kv.value
+            when "groups"
+              begin
+                fname = BayServer.parse_path(kv.value)
+                @groups.init(fname)
+              rescue IOError => e
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_FILE_NOT_FOUND, kv.value));
+              end
+            when "trains"
+              @train_runners = Integer(kv.value)
+            when "taxis", "taxies"
+              @taxi_runners = Integer(kv.value)
+            when "grandagents"
+              @grand_agents = Integer(kv.value)
+            when "maxships"
+              @max_ships = Integer(kv.value)
+            when "timeout"
+              @socket_timeout_sec = Integer(kv.value)
+            when "keeptimeout"
+              @keep_timeout_sec = Integer(kv.value)
+            when "tourbuffersize"
+              @tour_buffer_size = StringUtil.parse_size(kv.value)
+            when "traceheader"
+              @trace_header = StringUtil.parse_bool(kv.value)
+            when "redirectfile"
+              @redirect_file = kv.value
+            when "controlport"
+              @control_port = kv.value.to_i
+            when "multicore"
+              @multi_core = StringUtil.parse_bool(kv.value)
+            when "gzipcomp"
+              @gzip_comp = StringUtil.parse_bool(kv.value)
+            when "sendfilemethod"
+              case kv.value.downcase()
+              when "select"
+                @file_send_method = FILE_SEND_METHOD_SELECT
+              when "spin"
+                @file_send_method = FILE_SEND_METHOD_SPIN
+              when "taxi"
+                @file_send_method = FILE_SEND_METHOD_TAXI
+              else
+                raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, kv.value))
+              end
+            when "pidfile"
+              @pid_file = kv.value
+            else
+              return false
+            end
+            true
+          end
+
+          def trace_header?
+            @trace_header
+          end
+
+          def multi_core?
+            @multi_core
+          end
+        end
+      end
+    end
+  end
+end