bayserver-core 2.2.0

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

@@ -0,0 +1,56 @@
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/bay_log'
+
+module Baykit
+  module BayServer
+
+    module Util
+      class Message
+        include Bcf
+
+        attr_reader :messages
+
+        def initialize
+          @messages = {}
+        end
+
+        def init(file_prefix, locale)
+          lang = locale.language
+          file = file_prefix + ".bcf"
+          if(StringUtil.set?(lang) && lang != "en")
+            file = file_prefix + "_" + lang + ".bcf"
+          end
+
+          if(!File.exist?(file))
+            BayLog.warn("Cannot find message send_file: %s", file)
+            return
+          end
+
+          p = BcfParser.new()
+          doc = p.parse(file)
+
+          doc.content_list.each do |o|
+            if(o.instance_of? BcfKeyVal)
+              messages[o.key.to_sym] = o.value
+            end
+          end
+        end
+
+        #
+        # key : symbol
+        #
+        def get(key, *args)
+          if !key.instance_of? Symbol
+            raise RuntimeError "Key must be symbol"
+          end
+          msg = messages[key]
+          if msg == nil
+            msg = key.to_s
+          end
+          sprintf(msg, *args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'baykit/bayserver/bcf/package'
+
+module Baykit
+  module BayServer
+    module Util
+      class Mimes
+        include Baykit::BayServer::Bcf
+
+        @@mime_map = {}
+
+        def self.init(bcf_file)
+          p = BcfParser.new()
+          doc = p.parse(bcf_file)
+          doc.content_list.each do |kv|
+            if kv.instance_of? BcfKeyVal
+              @@mime_map[kv.key] = kv.value
+            end
+          end
+        end
+
+        def self.type(ext)
+          @@mime_map[ext.downcase]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Baykit
+  module BayServer
+    module Util
+      module ObjectFactory
+        #
+        # interface
+        #
+        # create_object()
+        #
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'baykit/bayserver/util/reusable'
+module Baykit
+  module BayServer
+    module Util
+      class ObjectStore
+        include Baykit::BayServer::Util::Reusable # implements
+
+        attr :free_list
+        attr :active_list
+        attr :factory
+
+        def initialize(factory=nil)
+          @free_list = []
+          @active_list = []
+          @factory = factory
+        end
+
+        def reset()
+          if @active_list.length > 0
+            BayLog.error("BUG?: There are %d active objects: %s", @active_list.length, @active_list)
+
+            # for security
+            @free_list.clear()
+            @active_list.clear()
+          end
+        end
+
+        def rent()
+          if @free_list.empty?
+            if @factory.instance_of? ObjectFactory
+              obj = @factory.create_object()
+            else
+              # lambda
+              obj = @factory.call()
+            end
+          else
+            obj = @free_list.delete_at(@free_list.length - 1)
+          end
+          if obj == nil
+            raise Sink.new()
+          end
+          @active_list.append(obj)
+          return obj
+        end
+
+        def Return(obj, reuse=true)
+          if @free_list.include?(obj)
+            raise Sink.new("This object already returned: " + obj.to_s)
+          end
+
+          if !@active_list.include?(obj)
+            raise Sink.new("This object is not active: " + obj)
+          end
+
+          @active_list.delete(obj)
+          if reuse
+            @free_list.append(obj)
+            obj.reset()
+          end
+        end
+
+        def print_usage(indent)
+          BayLog.info("%sfree list: %d", StringUtil.indent(indent), @free_list.length)
+          BayLog.info("%sactive list: %d", StringUtil.indent(indent), @active_list.length)
+          if BayLog.debug_mode?
+            @active_list.each do |obj|
+              BayLog.debug("%s%s", StringUtil.indent(indent+1), obj)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+
+module Baykit
+  module BayServer
+    module Util
+        module Postman # interface
+
+          def post(buf, adr, tag, lis)
+            raise NotImplementedError.new()
+          end
+
+          def flush()
+            raise NotImplementedError.new()
+          end
+
+          def post_end()
+            raise NotImplementedError.new()
+          end
+
+          def is_zombie()
+            raise NotImplementedError.new()
+          end
+
+          def abort()
+            raise NotImplementedError.new()
+          end
+
+          def open_valve()
+            raise NotImplementedError.new()
+          end
+
+        end
+    end
+  end
+end
+

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

@@ -0,0 +1,13 @@
+module Baykit
+  module BayServer
+    module Util
+      module Reusable
+        #
+        # interface
+        #
+        # reset()
+        #
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Baykit
+  module BayServer
+    module Util
+
+      #
+      # Like Selector class of Python
+      #
+      class Selector
+        OP_READ = 1
+        OP_WRITE = 2
+
+        attr :channels
+        attr :lock
+
+        def initialize
+          @channels = {}
+          @lock = Mutex.new()
+        end
+
+        def register(ch, op)
+          if op & OP_READ != 0
+            register_read(ch, @channels)
+          end
+          if op & OP_WRITE != 0
+            register_write(ch, @channels)
+          end
+        end
+
+        def unregister(ch)
+          unregister_read(ch, @channels)
+          unregister_write(ch, @channels)
+        end
+
+        def modify(ch, op)
+          if op & OP_READ != 0
+            register_read(ch, @channels)
+          else
+            unregister_read(ch, @channels)
+          end
+
+          if op & OP_WRITE != 0
+            register_write(ch, @channels)
+          else
+            unregister_write(ch, @channels)
+          end
+        end
+
+        def get_op(ch)
+          return @channels[ch]
+        end
+
+        def select(timeout = 0)
+          except_list = []
+
+          read_list = []
+          write_list = []
+          @lock.synchronize do
+            @channels.keys().each do |ch|
+              if (@channels[ch] & OP_READ) != 0
+                read_list << ch
+              end
+              if (@channels[ch] & OP_WRITE) != 0
+                write_list << ch
+              end
+            end
+          end
+          selected_read_list, selected_write_list = Kernel.select(read_list, write_list, except_list, timeout)
+
+          result = {}
+          if selected_read_list
+            selected_read_list.each do |ch|
+              register_read(ch, result)
+            end
+          end
+
+          if selected_write_list
+            selected_write_list.each do |ch|
+              register_write(ch, result)
+            end
+          end
+
+          return result
+        end
+
+        def count()
+          @lock.synchronize do
+            return @channels.length
+          end
+        end
+
+        private
+
+        def register_read(ch, ch_list)
+          @lock.synchronize do
+            if ch_list.include?(ch)
+              ch_list[ch] = (ch_list[ch] | OP_READ)
+            else
+              ch_list[ch] = OP_READ
+            end
+          end
+        end
+
+        def register_write(ch, ch_list)
+          @lock.synchronize do
+            if ch_list.include?(ch)
+              ch_list[ch] = (ch_list[ch] | OP_WRITE)
+            else
+              ch_list[ch] = OP_WRITE
+            end
+          end
+        end
+
+        def unregister_read(ch, ch_list)
+          @lock.synchronize do
+            if ch_list.include?(ch)
+              if ch_list[ch] == OP_READ
+                ch_list.delete(ch)
+              else
+                ch_list[ch] = OP_WRITE
+              end
+            end
+          end
+        end
+
+
+        def unregister_write(ch, ch_list)
+          @lock.synchronize do
+            if ch_list.include?(ch)
+              if ch_list[ch] == OP_WRITE
+                ch_list.delete(ch)
+              else
+                ch_list[ch] = OP_READ
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,53 @@
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/reusable'
+
+module Baykit
+  module BayServer
+    module Util
+      class SimpleBuffer
+        include Baykit::BayServer::Util::Reusable  # implements
+        INITIAL_BUFFER_SIZE = 32768
+
+        attr :buf
+        attr :length
+        attr :capacity
+
+        def initialize(init=INITIAL_BUFFER_SIZE)
+          @capacity = init
+          @buf = StringUtil.alloc(@capacity)
+          @length = 0
+        end
+
+        def bytes()
+          return buf
+        end
+
+        def reset()
+          # clear for security reason
+          @buf.clear()
+          @length = 0
+        end
+
+        def put_byte(b)
+          put([b], 0, 1);
+        end
+
+        def put(bytes, pos=0, len=bytes.length)
+          while @length + len > capacity
+            extend_buf
+          end
+
+          len.times do |i|
+            @buf[@length + i] = bytes[pos + i]
+          end
+          @length += len
+        end
+
+        def extend_buf()
+          @capacity *= 2
+          @buf = StringUtil.realloc(@buf, @capacity)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+
+module Baykit
+  module BayServer
+    module Util
+      module SimpleInspect
+        def inspect
+          self.class.to_s + "::" + object_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Baykit
+  module BayServer
+    module Util
+      class StringUtil
+        class << self
+          attr :falses
+          attr :trues
+        end
+
+        @falses = ["no", "false", "0", "off"]
+        @trues = ["yes", "true", "1", "on"]
+
+        def StringUtil.set?(str)
+          str != nil && str.length > 0
+        end
+
+        def StringUtil.empty?(str)
+          !set?(str)
+        end
+
+        def StringUtil.alloc(len)
+          String.new("", encoding: Encoding::ASCII_8BIT, capacity: len)
+        end
+
+        def StringUtil.realloc(buf, len)
+          String.new(buf, encoding: Encoding::ASCII_8BIT, capacity: len)
+        end
+
+        def StringUtil.to_bytes(buf)
+          buf.encode(encoding: Encoding::ASCII_8BIT)
+        end
+
+        def StringUtil.repeat(str, times)
+          return Array.new(times, str).join("")
+        end
+
+        def StringUtil.indent(count)
+          return repeat(" ", count);
+        end
+
+        def StringUtil.parse_bool(val)
+          val = val.downcase()
+          if @trues.include?(val)
+            return true
+          elsif @falses.include?(val)
+            return false
+          else
+            BayLog.warn("Invalid boolean value: %s", val)
+            return false
+          end
+        end
+
+        def StringUtil.parse_size(val)
+          val = val.downcase
+          rate = 1
+          if val.end_with?("b")
+            val = val[0, val.length - 1]
+          end
+
+          if val.end_with?("k")
+            val = val[0, val.length - 1]
+            rate = 1024
+          elsif val.end_with?("m")
+            val = val[0, val.length - 1]
+            rate = 1024 * 1024
+          end
+
+          Integer(val) * rate
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+require 'etc'
+require 'pathname'
+require 'tmpdir'
+
+require 'baykit/bayserver/bay_log'
+require 'baykit/bayserver/bayserver'
+
+module Baykit
+  module BayServer
+    module Util
+      class SysUtil
+
+        def SysUtil.run_on_windows()
+          return RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|cygwin|bccwin/
+        end
+
+        #
+        # We set environment variable "RUBYMINE" to 1 for debugging
+        #
+        def SysUtil.run_on_rubymine()
+          return ENV["RUBYMINE"] == "1"
+        end
+
+        def SysUtil.support_fork()
+          begin
+            pid = fork()
+            if pid == nil
+              exit(0)
+            end
+            Process.waitpid(pid)
+            return true
+          rescue NotImplementedError => e
+            if BayLog.debug_mode?
+              BayLog.warn("fork() failed: %s ", e)
+              #BayLog.warn_e(e)
+            end
+            return false
+          end
+        end
+
+
+        def SysUtil.support_select_file()
+          File.open(BayServer.bserv_plan) do |f|
+            begin
+              n = select([f], [], [], 10)
+              return true
+            rescue IOError => e
+              if BayLog.debug_mode?
+                BayLog.warn("select() failed: %s", e)
+                #BayLog.warn_e(e)
+              end
+              return false
+            end
+          end
+        end
+
+
+        def SysUtil.support_nonblock_file_read()
+          File.open(BayServer.bserv_plan) do |f|
+            begin
+              f.read_nonblock(1)
+              return true
+            rescue SystemCallError => e
+              if BayLog.debug_mode?
+                BayLog.warn("read_nonblock() failed: %s", e)
+                #BayLog.warn_e(e)
+              end
+              return false
+            end
+          end
+        end
+
+        def SysUtil.support_nonblock_file_write()
+          Dir.mktmpdir() do |dir|
+            File.open(Pathname(dir) + "test_file", "wb") do |f|
+              begin
+                f.write_nonblock(1)
+                return true
+              rescue SystemCallError => e
+                if BayLog.debug_mode?
+                  BayLog.warn("write_nonblock() failed: %s", e)
+                  #BayLog.warn_e(e)
+                end
+                return false
+              end
+            end
+          end
+        end
+
+
+        def SysUtil.support_select_pipe()
+          IO.pipe() do |r, w|
+            begin
+              n = select([r], [w], [], 10)
+              return true
+            rescue IOError => e
+              if BayLog.debug_mode?
+                BayLog.warn("select() failed: %s", e)
+                #BayLog.warn_e(e)
+              end
+              return false
+            end
+          end
+        end
+
+
+        def SysUtil.support_nonblock_pipe_read()
+          IO.pipe() do |r, w|
+            w.write("abcd")
+            begin
+              r.read_nonblock(1)
+              return true
+            rescue SystemCallError => e
+              if BayLog.debug_mode?
+                BayLog.warn("read_nonblock() failed: %s", e)
+                #BayLog.warn_e(e)
+              end
+              return false
+            end
+          end
+        end
+
+        def SysUtil.pid()
+          return $$
+        end
+
+        def SysUtil.processor_count()
+          return Etc.nprocessors
+        end
+
+        def SysUtil.support_unix_domain_socket_address()
+          return !SysUtil.run_on_windows()
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Baykit
+  module BayServer
+    module Util
+      class URLDecoder
+
+        def self.decode(str, enc)
+          parse_special(str, enc)
+        end
+
+        def self.parse_special(str, enc)
+          arr = ByteArray.new
+          index = 0
+
+          while(index < str.length)
+            c = str[index]
+            case c
+            when '+'
+              arr.put_bytes(c)
+              index = index + 1
+
+            when '%'
+              hex_str = str[index + 1 .. index + 2]
+              ch = hex_str.hex
+              arr.put_bytes([ch])
+              index += 3
+
+            else
+              arr.put_bytes(c)
+              index += 1
+            end
+          end
+
+          if(StringUtil.empty?(enc))
+            return arr.buf
+          else
+            return arr.buf.encode(enc)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Baykit
+  module BayServer
+    module Util
+      class URLEncoder
+        def URLEncoder.encode_tilde(url)
+          buf = ""
+          url.each_char do |c|
+            if(c == "~")
+              buf.concat("%7E")
+            else
+              buf.concat(c)
+            end
+          end
+          return buf
+        end
+      end
+    end
+  end
+end