bayserver-core 2.2.0

data/lib/baykit/bayserver/bcf/bcf_parser.rb

@@ -0,0 +1,180 @@
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/bay_message'
+
+module Baykit
+  module BayServer
+    module Bcf
+
+      class BcfParser
+
+        attr :file_name
+        attr :line_no
+        attr :input
+        attr :prev_line_info
+        attr :indent_map
+
+        class LineInfo
+          attr :line_obj
+          attr :indent
+
+          def initialize(line_obj, indent)
+            if indent == nil
+              raise RuntimeError.new("indent is nil")
+            end
+            @line_obj = line_obj
+            @indent = indent
+          end
+        end
+
+        def initialize
+          @indent_map = []
+        end
+
+        def parse(file)
+          doc = BcfDocument.new
+
+          @file_name = file
+          @line_no = 0
+          @input = File.open(file)
+          parse_same_level(doc.content_list, 0)
+          @input.close
+          return doc
+        end
+
+        protected
+
+        def push_indent(sp_count)
+          @indent_map << sp_count
+        end
+
+        def pop_indent
+          @indent_map.delete_at(@indent_map.length - 1)
+        end
+
+        def get_indent(sp_count)
+          if @indent_map.empty?
+            push_indent sp_count
+          elsif sp_count > @indent_map[indent_map.length - 1]
+            push_indent sp_count
+          end
+
+          indent = @indent_map.index(sp_count)
+
+          if indent == nil
+            raise ParseException.new(@file_name, @line_no, BayMessage.get(:PAS_INVALID_INDENT))
+          end
+
+          return indent
+        end
+
+
+        def parse_same_level(cur_list, indent)
+          object_exists_in_same_level = false
+          while true
+            if @prev_line_info != nil
+              line_info = @prev_line_info
+              @prev_line_info = nil
+            else
+              line = @input.gets
+              @line_no += 1
+
+              if line == nil
+                break
+              end
+
+              if line.strip.start_with?("#") || line.strip == ""
+                next
+              end
+
+              line_info = parse_line(@line_no, line)
+            end
+
+            if line_info == nil
+              # Comment or empty
+              next
+
+            elsif line_info.indent > indent
+              # lower level
+              raise ParseException.new(@file_name, @line_no, BayMessage.get(:PAS_INVALID_INDENT))
+
+            elsif line_info.indent < indent
+              # upper level
+              @prev_line_info = line_info
+              if object_exists_in_same_level
+                pop_indent
+              end
+              return line_info
+
+            else
+              object_exists_in_same_level = true
+
+              # samel level
+              if line_info.line_obj.instance_of? BcfElement
+                # BcfElement
+                cur_list << line_info.line_obj
+
+                last_line_info = parse_same_level(line_info.line_obj.content_list, line_info.indent + 1)
+                if last_line_info == nil
+                  # EOF
+                  pop_indent
+                  return nil
+                else
+                  # Same level
+                  next
+                end
+              else
+                # IniKeyVal
+                cur_list << line_info.line_obj
+              end
+            end
+          end
+          pop_indent
+          return nil
+        end
+
+        def parse_line (line_no, line)
+
+          sp_count = 0
+          for sp_count in line.length.times
+            c = line[sp_count]
+            if c.strip != ''
+              # c is not awhitespace
+              break
+            end
+
+            if c != ' '
+              raise ParseException.new(@file_name, @line_no, BayMessage.get(:PAS_INVALID_WHITESPACE))
+            end
+          end
+
+          indent = get_indent(sp_count)
+          line = line.slice(sp_count .. -1)
+          line.strip!
+
+          if line.start_with?("[")
+            close_pos = line.index("]");
+            if close_pos == -1
+              raise ParseException.new(@file_name, @line_no, :PAS_BRACE_NOT_CLOSED)
+            end
+
+            if !line.end_with?("]")
+              raise ParseException.new(@file_name, @line_no, :PAS_INVALID_LINE)
+            end
+
+            key_val = parse_key_val(line.slice(1, close_pos - 1), line_no);
+            return LineInfo.new(BcfElement.new(key_val.key, key_val.value, @file_name, line_no), indent)
+          else
+            return LineInfo.new(parse_key_val(line, line_no), indent)
+          end
+        end
+
+        def parse_key_val(line, line_no)
+          sp_pos = line.index(' ')
+          key = sp_pos == nil ? line : line[0, sp_pos]
+          val = sp_pos == nil ? "" : line[sp_pos .. -1].strip
+          return BcfKeyVal.new(key, val, @file_name, line_no);
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require 'baykit/bayserver/bcf/bcf_object'
+require 'baykit/bayserver/bcf/bcf_key_val'
+require 'baykit/bayserver/bcf/bcf_element'
+require 'baykit/bayserver/bcf/bcf_document'
+require 'baykit/bayserver/bcf/bcf_parser'
+require 'baykit/bayserver/bcf/parse_exception'

data/lib/baykit/bayserver/bcf/parse_exception.rb

@@ -0,0 +1,15 @@
+require 'baykit/bayserver/config_exception'
+require 'baykit/bayserver/bcf/package'
+
+module Baykit
+  module BayServer
+    module Bcf
+      class ParseException < ConfigException
+
+        def initialize(file_name, line_no, msg)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/config_exception.rb

@@ -0,0 +1,25 @@
+require 'baykit/bayserver/bay_exception'
+
+module Baykit
+  module BayServer
+
+    class ConfigException < BayException
+      attr_reader :file_name
+      attr_reader :line_no
+
+      def initialize(file_name, line_no, fmt, *args)
+        super(fmt, *args)
+        @file_name = file_name
+        @line_no = line_no
+      end
+
+      def message()
+        return ConfigException::create_message(super, @file_name, @line_no)
+      end
+
+      def self::create_message(msg, fname, line)
+        return "#{msg == nil ? "" : msg} #{fname}:#{line}"
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/constants.rb

@@ -0,0 +1,8 @@
+
+module Baykit
+  module BayServer
+    module Constants
+
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require 'baykit/bayserver/docker/club'
+require 'baykit/bayserver/docker/base/docker_base'
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/util/class_util'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class ClubBase < Baykit::BayServer::Docker::Base::DockerBase
+          include Baykit::BayServer::Docker::Club # implements
+
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+
+          attr :file_name
+          attr :extension
+          attr :charset
+          attr :locale
+          attr :decode_path_info
+
+          def initialize
+            @file_name = nil
+            @extension = nil
+            @charset = nil
+            @locale = nil
+            @decode_path_info = true
+          end
+
+          def to_s()
+            return ClassUtil.get_local_name(self.class)
+          end
+          
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            super
+            p = elm.arg.rindex('.');
+            if(p == nil)
+              @file_name = elm.arg
+              @extension = nil
+            else
+              @file_name = elm.arg[0, p]
+              @extension = elm.arg[p+1 .. -1]
+            end
+
+          end
+
+          ######################################################
+          # Implements DockerBase
+          ######################################################
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "decodepathinfo"
+              @decode_path_info = StringUtil.parse_bool(kv.value)
+            when "charset"
+              @charset = kv.value
+            else
+              return super
+            end
+            return true
+          end
+
+          ######################################################
+          # Implements Club
+          ######################################################
+
+          def matches(fname)
+            # check club
+            pos = fname.index(".")
+            if(pos == nil)
+              # fname has no extension
+              if(@extension != nil)
+                return false
+              end
+
+              if(@file_name == "*")
+                return true
+              end
+
+              return fname == @file_name
+            else
+              # fname has extension
+              if(@extension == nil)
+                return false
+              end
+
+              nm = fname[0, pos]
+              ext = fname[pos + 1 .. -1]
+
+              if(@extension != "*" && ext != @extension)
+                return false
+              end
+
+              if(@file_name == "*")
+                return true
+              else
+                return nm == @file_name
+              end
+            end
+          end
+
+          def to_s
+            self.class.name
+          end
+
+          def inspect
+            self.class.name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'baykit/bayserver/util/class_util'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class DockerBase
+          include Baykit::BayServer::Docker::Docker # implements
+          include Baykit::BayServer::Bcf
+
+          include Baykit::BayServer::Util
+
+          attr :type
+
+          def to_s()
+            return ClassUtil.get_local_name(self.class)
+          end
+
+          def init(elm, parent)
+            @type = elm.name
+            elm.content_list.each do |o|
+              if o.kind_of? BcfKeyVal
+                begin
+                  if !init_key_val(o)
+                    raise ConfigException.new o.file_name, o.line_no, BayMessage.get(:CFG_INVALID_PARAMETER, o.key)
+                  end
+                rescue ConfigException => e
+                  raise e
+                rescue => e
+                  BayLog.error_e(e)
+                  raise ConfigException.new o.file_name, o.line_no, BayMessage.get(:CFG_INVALID_PARAMETER_VALUE, o.key)
+                end
+              else
+                begin
+                  dkr = BayServer.dockers.create_docker(o, self)
+                rescue ConfigException => e
+                  raise e
+                rescue => e
+                  BayLog.error_e e
+                  raise ConfigException.new(o.file_name, o.line_no, BayMessage.get(:CFG_INVALID_DOCKER, o.name))
+                end
+
+                if(!init_docker(dkr))
+                  raise ConfigException.new(o.file_name, o.line_no, BayMessage.get(:CFG_INVALID_DOCKER, o.name))
+                end
+              end
+            end
+          end
+
+          def init_docker(dkr)
+            return false;
+          end
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "docker"
+              return true
+            else
+              return false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'baykit/bayserver/agent/next_socket_action'
+require 'baykit/bayserver/agent/transporter/data_listener'
+require 'baykit/bayserver/watercraft/ship'
+require 'baykit/bayserver/tours/package'
+
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        class InboundDataListener
+
+          include Baykit::BayServer::Agent::Transporter::DataListener   # implements
+          include Baykit::BayServer::Agent
+
+          attr :ship
+
+          def initialize(sip)
+            @ship = sip
+          end
+
+          def to_s
+            return @ship.to_s
+          end
+
+          ######################################################
+          # Implements DataListener
+          ######################################################
+
+          def notify_connect()
+            raise Sink.new()
+          end
+
+          def notify_handshake_done(protocol)
+            BayLog.trace("%s notify_handshake_done: proto=%s", self, protocol)
+            return NextSocketAction::CONTINUE
+          end
+
+          def notify_read(buf, adr)
+            BayLog.trace("%s notify_read", self)
+            return @ship.protocol_handler.bytes_received(buf)
+          end
+
+          def notify_eof()
+            BayLog.trace("%s notify_eof", self)
+            return NextSocketAction::CLOSE
+          end
+
+          def notify_protocol_error(err)
+            BayLog.trace("%s notify_protocol_error", self)
+            if BayLog.debug_mode?
+              BayLog.error_e(err)
+            end
+            return @ship.protocol_handler.send_req_protocol_error(err)
+          end
+
+          def notify_close
+            BayLog.debug("%s notify_close", self)
+
+            @ship.abort_tours()
+
+            if !@ship.active_tours.empty?
+              # cannot close because there are some running tours
+              BayLog.debug("%s cannot end ship because there are some running tours (ignore)", self)
+              @ship.need_end = true
+            else
+              @ship.end_ship()
+            end
+
+          end
+
+          def check_timeout(duration_sec)
+            if @ship.socket_timeout_sec <= 0
+              timeout = false;
+            elsif @ship.keeping
+              timeout = duration_sec >= BayServer.harbor.keep_timeout_sec
+            else
+              timeout = duration_sec >= @ship.socket_timeout_sec
+            end
+            BayLog.debug("%s Check timeout: dur=%d timeout=%s, keeping=%s, limit=%d",
+                         self, duration_sec, timeout, @ship.keeping, @ship.socket_timeout_sec)
+            return timeout
+          end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,42 @@
+module Baykit
+  module BayServer
+    module Docker
+      module Base
+        module InboundHandler  # interface
+
+          #
+          #  Send protocol error
+          #   return true if connection must be closed
+          #
+          def send_req_protocol_error(protocol_ex)
+            raise NotImplementedError()
+          end
+
+          #
+          #  Send HTTP headers to client
+          #
+          def send_res_headers(tur)
+            raise NotImplementedError()
+          end
+
+          #
+          # Send Contents to client
+          #
+          def send_res_content(tur, bytes, ofs, len, &callback)
+            raise NotImplementedError()
+          end
+
+          #
+          # Send end of contents to client.
+          #  sendEnd cannot refer Tour instance because it is discarded before call.
+          #
+          def send_end_tour(tur, keep_alive, &callback)
+            raise NotImplementedError()
+          end
+
+        end
+      end
+    end
+  end
+end
+