bayserver-core 2.2.0

data/lib/baykit/bayserver/util/cgi_util.rb

@@ -0,0 +1,165 @@
+require 'baykit/bayserver/util/string_util'
+
+module Baykit
+  module BayServer
+    module Util
+      class CgiUtil
+
+        REQUEST_METHOD = "REQUEST_METHOD"
+        REQUEST_URI = "REQUEST_URI"
+        SERVER_PROTOCOL = "SERVER_PROTOCOL"
+        GATEWAY_INTERFACE = "GATEWAY_INTERFACE"
+        SERVER_NAME = "SERVER_NAME"
+        SERVER_PORT = "SERVER_PORT"
+        QUERY_STRING = "QUERY_STRING"
+        SCRIPT_NAME = "SCRIPT_NAME"
+        SCRIPT_FILENAME = "SCRIPT_FILENAME"
+        PATH_TRANSLATED = "PATH_TRANSLATED"
+        PATH_INFO = "PATH_INFO"
+        CONTENT_TYPE = "CONTENT_TYPE"
+        CONTENT_LENGTH = "CONTENT_LENGTH"
+        REMOTE_ADDR = "REMOTE_ADDR"
+        REMOTE_PORT = "REMOTE_PORT"
+        REMOTE_USER = "REMOTE_USER"
+        HTTP_ACCEPT = "HTTP_ACCEPT"
+        HTTP_COOKIE = "HTTP_COOKIE"
+        HTTP_HOST = "HTTP_HOST"
+        HTTP_USER_AGENT = "HTTP_USER_AGENT"
+        HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING"
+        HTTP_ACCEPT_LANGUAGE = "HTTP_ACCEPT_LANGUAGE"
+        HTTP_CONNECTION = "HTTP_CONNECTION"
+        HTTP_UPGRADE_INSECURE_REQUESTS = "HTTP_UPGRADE_INSECURE_REQUESTS"
+        HTTPS = "HTTPS"
+        PATH = "PATH"
+        SERVER_SIGNATURE = "SERVER_SIGNATURE"
+        SERVER_SOFTWARE = "SERVER_SOFTWARE"
+        SERVER_ADDR = "SERVER_ADDR"
+        DOCUMENT_ROOT = "DOCUMENT_ROOT"
+        REQUEST_SCHEME = "REQUEST_SCHEME"
+        CONTEXT_PREFIX = "CONTEXT_PREFIX"
+        CONTEXT_DOCUMENT_ROOT = "CONTEXT_DOCUMENT_ROOT"
+        SERVER_ADMIN = "SERVER_ADMIN"
+        REQUEST_TIME_FLOAT = "REQUEST_TIME_FLOAT"
+        REQUEST_TIME = "REQUEST_TIME"
+        UNIQUE_ID = "UNIQUE_ID"
+        X_FORWARDED_HOST = "X_FORWARDED_HOST"
+        X_FORWARDED_FOR = "X_FORWARDED_FOR"
+        X_FORWARDED_PROTO = "X_FORWARDED_PROTO"
+        X_FORWARDED_PORT = "X_FORWARDED_PORT"
+
+        def self.get_env_hash(path, doc_root, script_base, tur)
+          map = {}
+          get_env(path, doc_root, script_base, tur) do |name, value|
+            map[name] = value
+          end
+          map
+        end
+
+
+        def self.get_env(path, doc_root, script_base, tur, &block)
+
+          req_headers = tur.req.headers
+
+          ctype = req_headers.content_type
+          if StringUtil.set? ctype
+            pos = ctype.index("charset=")
+            if pos != nil && pos >= 0
+              tur.req.charset = ctype[pos+8 .. -1].strip
+            end
+          end
+
+          add_env(REQUEST_METHOD, tur.req.method, &block)
+          add_env(REQUEST_URI, tur.req.uri, &block)
+          add_env(SERVER_PROTOCOL, tur.req.protocol, &block)
+          add_env(GATEWAY_INTERFACE, "CGI/1.1", &block)
+
+          add_env(SERVER_NAME, tur.req.req_host, &block)
+          add_env(SERVER_ADDR, tur.req.server_address, &block)
+          if tur.req.req_port >= 0
+            add_env(SERVER_PORT, tur.req.req_port, &block)
+          end
+
+          add_env(SERVER_SOFTWARE, BayServer.get_software_name, &block)
+          add_env(CONTEXT_DOCUMENT_ROOT, doc_root, &block)
+
+          tur.req.headers.names.each do |name|
+            newval = nil
+            tur.req.headers.values(name).each do |value|
+              if newval == nil
+                newval = value
+              else
+                newval = newval + "; " + value
+              end
+            end
+
+            name = name.upcase.tr('-', '_')
+            if name.start_with?("X_FORWARDED_")
+              add_env(name, newval, &block)
+            else
+              case name
+              when CONTENT_TYPE, CONTENT_LENGTH
+                add_env(name, newval, &block)
+              else
+                add_env("HTTP_" + name, newval, &block)
+              end
+            end
+          end
+
+          add_env(REMOTE_ADDR, tur.req.remote_address, &block)
+          add_env(REMOTE_PORT, tur.req.remote_port, &block)
+          #add_env(REMOTE_USER, "unknown")
+
+          add_env(REQUEST_SCHEME, tur.is_secure ? "https": "http", &block)
+          tmp_secure = tur.is_secure
+          fproto = tur.req.headers.get(Headers::X_FORWARDED_PROTO)
+          if fproto != nil
+            tmp_secure = fproto.casecmp?("https")
+          end
+          if tmp_secure
+            add_env(HTTPS, "on", &block)
+          end
+
+          add_env(QUERY_STRING, tur.req.query_string, &block)
+          add_env(SCRIPT_NAME, tur.req.script_name, &block)
+          add_env(UNIQUE_ID, DateTime.now.to_s, &block)
+
+          if tur.req.path_info == nil
+            add_env(PATH_INFO, "", &block)
+          else
+            add_env(PATH_INFO, tur.req.path_info, &block)
+
+            locpath = doc_root
+            if locpath.end_with? "/"
+              locpath = locpath[0 .. -2]
+            end
+
+            path_translated = locpath + tur.req.path_info
+            add_env(PATH_TRANSLATED, path_translated, &block)
+          end
+
+          if !script_base.end_with?("/")
+            script_base = script_base + "/"
+          end
+
+          add_env(SCRIPT_FILENAME, "#{script_base}#{tur.req.script_name[path.length .. -1]}", &block)
+          add_env(PATH, ENV["PATH"], &block)
+        end
+
+        private
+        def self.add_env(key, value)
+          if value == nil
+            value = ""
+          end
+          
+          # Handles null terminated string
+          value = value.to_s.split("\0")[0]
+          if value == nil
+            value = ""
+          end
+
+          yield(key, value.to_s)
+        end 
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/char_util.rb

@@ -0,0 +1,22 @@
+module Baykit
+  module BayServer
+    module Util
+      class CharUtil
+
+        CR = "\r"
+        LF = "\n"
+        CRLF = "\r\n"
+
+        CR_BYTE = CR.codepoints[0]
+        LF_BYTE = LF.codepoints[0]
+
+
+        def CharUtil.is_ascii(c)
+          cp = c.codepoints[0]
+          cp >= 32 && cp <= 126
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/util/cities.rb

@@ -0,0 +1,45 @@
+module Baykit
+  module BayServer
+    module Util
+      class Cities
+
+        attr :any_city
+        attr :cities
+
+        def initialize
+          @any_city = nil
+          @cities = []
+        end
+
+        def add(c)
+          if c.name == "*"
+            @any_city = c
+          else
+            @cities << c
+          end
+        end
+
+
+        def find_city(name)
+          # Check exact match
+          @cities.each do |city|
+            if city.name == name
+              return city
+            end
+          end
+          return @any_city
+        end
+
+        def cities()
+          ret = @cities.dup
+          if @any_city != nil
+            ret << @any_city
+          end
+          return ret
+        end
+
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/util/class_util.rb

@@ -0,0 +1,17 @@
+module Baykit
+  module BayServer
+    module Util
+      class ClassUtil
+        def self.get_local_name(cls)
+          name = cls.name
+          p = name.rindex(':')
+          if(p != nil)
+            name = name[p + 1 .. -1]
+          end
+          return name
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/util/counter.rb

@@ -0,0 +1,23 @@
+module Baykit
+  module BayServer
+    module Util
+      class Counter
+        attr :counter
+        attr :mutex
+
+        def initialize(init=1)
+          @counter = init
+          @mutex = Mutex.new
+        end
+
+        def next
+          @mutex.synchronize do
+            c = @counter
+            @counter += 1
+            c
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/data_consume_listener.rb

@@ -0,0 +1,13 @@
+module Baykit
+  module BayServer
+    module Util
+      class DataConsumeListener
+        #
+        # interface
+        #
+        # done()
+        #
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/executor_service.rb

@@ -0,0 +1,81 @@
+
+#
+# ExecutorService
+#   Implementation of thread pool
+#
+module Baykit
+  module BayServer
+    module Util
+      class ExecutorService
+
+        class Executor
+
+          attr :que
+          attr :id
+          attr :name
+
+          def initialize(que, id, name)
+            @que = que
+            @id = id
+            @name = name
+          end
+
+          def run
+            while true
+              tsk = @que.deq
+              #BayLog.debug("%s Start task on: %s", tsk, @name)
+              tsk.run
+              #BayLog.debug("%s End task on: %s", tsk, @name)
+            end
+          end
+
+          def to_s
+            @name
+          end
+        end
+
+        MAX_LEN_PER_EXECUTOR = 32
+
+        attr :que
+        attr :count
+        attr :max_queue_len
+        attr :name
+
+        def initialize(name, count)
+          @que = Thread::Queue.new
+          @count = count
+          @max_queue_len = MAX_LEN_PER_EXECUTOR * count
+          @name = name
+
+          count.times do |i|
+            started = false
+            Thread.new do
+              started = true
+              id = i + 1
+              th_name = "Executor[#{name}]##{id}"
+              Thread.current.name = th_name
+              e = Executor.new @que, id, th_name
+              e.run
+            end
+            while !started
+              sleep(0.01)
+            end
+          end
+        end
+
+        def to_s()
+          return "ExecutorService[#{@name}]"
+        end
+
+        # post task
+        def submit(tsk)
+          BayLog.debug("%s Submit: task=%s (qlen=%d/%d)", self, tsk, @que.length, @max_queue_len)
+          if @que.length > @max_queue_len
+            raise IOError("Task queue is full (>_<)")
+          end
+          @que.enq(tsk)
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/groups.rb

@@ -0,0 +1,110 @@
+require 'baykit/bayserver/util/md5_password'
+require 'baykit/bayserver/bcf/package'
+
+module Baykit
+  module BayServer
+    module Util
+      class Groups
+        include Baykit::BayServer::Bcf
+
+        class Member
+          attr :name
+          attr :digest
+
+          def initialize(name, digest)
+            @name = name
+            @digest = digest
+          end
+
+          def validate(password)
+            if password == nil
+              return false
+            end
+
+            dig = MD5Password.encode(password)
+            return dig == @digest
+          end
+        end
+
+        class Group
+          attr :name
+          attr :members
+          attr :groups
+
+          def initialize(groups, name)
+            @name = name
+            @groups = groups
+            @members = []
+          end
+
+          def add(mem)
+            @members << mem
+          end
+
+          def validate(mem_name, pass)
+            if !@members.include?(mem_name)
+              return false
+            end
+
+            m = @groups.all_members[mem_name]
+            if m == nil
+              return false
+            end
+
+            return m.validate(pass)
+          end
+        end
+
+        attr :all_groups
+        attr :all_members
+
+        def initialize
+          @all_groups = {}
+          @all_members = {}
+        end
+
+        def init(bcf)
+          p = BcfParser.new
+          doc = p.parse(bcf)
+
+          doc.content_list.each do |obj|
+            if obj.instance_of? BcfElement
+              if obj.name.casecmp?("group")
+                init_groups(obj)
+              elsif obj.name.casecmp?("member")
+                init_members(obj)
+              end
+            end
+          end
+        end
+
+
+        def get_group(name)
+          return @all_groups[name]
+        end
+
+
+        private
+        def init_groups(elm)
+          elm.content_list.each do |obj|
+            if obj.instance_of? BcfKeyVal
+              g = Group.new(self, obj.key)
+              @all_groups[obj.key] = g
+
+              obj.value.split(" ").each do |mem_name|
+                g.add(mem_name)
+              end
+            end
+          end
+        end
+
+        def init_members(elm)
+          elm.content_list.each do |obj|
+            m = Member.new(obj.key, obj.value)
+            @all_members[m.name] = m
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/gzip_compressor.rb

@@ -0,0 +1,55 @@
+require 'zlib'
+
+module Baykit
+  module BayServer
+    module Util
+      class GzipCompressor
+
+        class CompressListener
+          # interface
+          # def on_compressed(*str)
+        end
+
+        class CallbackWriter
+
+          attr :gzip_comp
+          attr_accessor :done_listener
+
+          def initialize(gzip_comp)
+            @gzip_comp = gzip_comp
+            @done_listener = nil
+          end
+
+          def write(*str)
+            # proc
+            str.each do |item|
+              @gzip_comp.listener.call(item, 0, item.length, &@done_listener)
+            end
+          end
+        end
+
+        attr :listener
+        attr :gout
+        attr :cb_writer
+
+        def initialize(comp_lis)
+          @listener = comp_lis
+          @cb_writer = CallbackWriter.new(self)
+          @gout = Zlib::GzipWriter.new(@cb_writer)
+        end
+
+        def compress(buf, ofs, len, &lis)
+          @cb_writer.done_listener = lis
+          @gout.write(buf[ofs .. ofs + len - 1])
+          @gout.flush()
+        end
+
+        def finish()
+          #@gout.finish()
+          @gout.close()
+        end
+
+      end
+    end
+  end
+end