bayserver-core 2.2.0

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

@@ -0,0 +1,117 @@
+require 'baykit/bayserver/docker/club'
+require 'baykit/bayserver/docker/town'
+require 'baykit/bayserver/docker/reroute'
+require 'baykit/bayserver/docker/permission'
+require 'baykit/bayserver/docker/base/docker_base'
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+        class BuiltInTownDocker < Baykit::BayServer::Docker::Base::DockerBase
+          include Baykit::BayServer::Docker::Town #implements
+
+          include Baykit::BayServer::Docker
+          include Baykit::BayServer::Bcf
+
+          attr :name
+          attr :location
+          attr :welcome
+          attr :clubs
+          attr :permission_list
+          attr :city
+          attr :reroute_list
+
+          def initialize
+            @name = nil
+            @location = nil
+            @welcome = nil
+            @clubs = []
+            @permission_list = []
+            @city = nil
+            @reroute_list = []
+          end
+
+          ######################################################
+          # Implements Docker
+          ######################################################
+
+          def init(elm, parent)
+            arg = elm.arg
+            if !arg.start_with? "/"
+              arg = "/" + arg
+            end
+
+            @name = arg
+            if !@name.end_with? "/"
+              @name = @name + "/"
+            end
+
+            @city = parent
+            super
+          end
+
+          def init_docker(dkr)
+            if dkr.kind_of?(Baykit::BayServer::Docker::Club)
+              @clubs.append(dkr)
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Permission)
+              @permission_list.append(dkr)
+            elsif dkr.kind_of?(Baykit::BayServer::Docker::Reroute)
+              @reroute_list.append(dkr)
+            else
+              return super
+            end
+            return true
+          end
+
+          def init_key_val(kv)
+            case kv.key.downcase
+            when "location"
+              @location = kv.value
+              if !File.absolute_path?(@location)
+                @location = BayServer.get_location(@location)
+                if !File.directory?(@location)
+                  raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_LOCATION, kv.value))
+                end
+              end
+            when "index"
+              @welcome = kv.value
+            when "welcome"
+              @welcome = kv.value
+            else
+              return super
+            end
+            return true;
+          end
+
+          ######################################################
+          # Implements Town
+          ######################################################
+
+          def reroute(uri)
+            @reroute_list.each do |r|
+              uri = r.reroute(self, uri)
+            end
+            return uri
+          end
+
+          def matches(uri)
+            if uri.start_with?(@name)
+              return MATCH_TYPE_MATCHED
+            elsif uri + "/" == name
+              return MATCH_TYPE_CLOSE
+            else
+              return MATCH_TYPE_NOT_MATCHED
+            end
+          end
+
+          def tour_admitted(tur)
+            @permission_list.each do |p|
+              p.tour_admitted(tur)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'ipaddr'
+
+require 'baykit/bayserver/bcf/package'
+require 'baykit/bayserver/docker/trouble'
+
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+        class BuiltInTroubleDocker < Baykit::BayServer::Docker::Base::DockerBase
+          include Trouble # import
+
+          include Baykit::BayServer
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+
+          attr :cmd_map
+
+          def initialize
+            @cmd_map = {}
+          end
+
+          def init_key_val(kv)
+            status = Integer(kv.key)
+
+            pos = kv.value.index(' ')
+            if(pos == nil)
+              raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER, kv.key))
+            end
+
+            mstr = kv.value[0, pos]
+            method = nil
+            if(mstr.casecmp?("guide"))
+              method = Method::GUIDE
+            elsif(mstr.casecmp?("text"))
+              method = Method::TEXT;
+            elsif(mstr.casecmp?("reroute"))
+              method = Method::REROUTE;
+            else
+              raise ConfigException.new(kv.file_name, kv.line_no, BayMessage.get(:CFG_INVALID_PARAMETER, kv.key))
+            end
+
+            @cmd_map[status] = Command.new(method, kv.value[pos + 1 .. -1])
+            return true;
+          end
+        end
+
+        def find(status)
+          @cmd_map[status]
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,71 @@
+require 'baykit/bayserver/agent/transporter/data_listener'
+require 'baykit/bayserver/protocol/packet'
+require 'baykit/bayserver/watercraft/boat'
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+        class LogBoat < Baykit::BayServer::WaterCraft::Boat
+          include Baykit::BayServer::Agent::Transporter::DataListener
+          include Baykit::BayServer::Protocol
+
+          class LogPacket < Packet
+            def initialize(data)
+              super(0, 0, data.length)
+              new_data_accessor().put_string(data)
+            end
+          end
+
+          attr :file_name
+          attr :postman
+
+          def initialize()
+            super
+          end
+
+          def to_s()
+            return "lboat##{@boart_id}/#{@object_id} file=#{@file_name}";
+          end
+
+          ######################################################
+          # Implements Reusable
+          ######################################################
+
+          def reset()
+            @file_name = nil
+            @postman = nil
+          end
+
+          ######################################################
+          # Implements DataListener
+          ######################################################
+
+          def notify_close()
+            BayLog.info("Log closed: %s", self.file_name)
+          end
+
+          ######################################################
+          # Custom methods
+          ######################################################
+
+          def init(file_name, postman)
+            init_boat()
+            @file_name = file_name
+            @postman = postman
+          end
+
+          def log(data)
+            if data == nil
+              data = ""
+            end
+            data += CharUtil::LF
+
+            @postman.post(data, nil, file_name)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+
+        class LogItem
+          def init(param)
+          end
+
+          def get_item(tour)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+
+
+        class LogItemFactory
+          #
+          # interface
+          #
+          #         LogItem newLogItem();
+          #
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,287 @@
+require 'baykit/bayserver/docker/built_in/log_item'
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+
+        module LogItems
+          #
+          # Return static text
+          #
+          class TextItem < LogItem
+            attr :text
+
+            def initialize(text)
+              @text = text
+            end
+
+            def get_item(tour)
+              return @text
+            end
+          end
+
+          #
+          # Return null result
+          #
+          class NullItem < LogItem
+            def get_item(tur)
+              return nil
+            end
+          end
+
+          #
+          # Return remote IP address (%a)
+          #
+          class RemoteIpItem < LogItem
+            def get_item(tur)
+              return tur.req.remote_address
+            end
+          end
+
+          #
+          # Return local IP address (%A)
+          #
+          class ServerIpItem < LogItem
+            def get_item(tur)
+              return tur.sever_address
+            end
+          end
+
+          #
+          # Return number of bytes that is sent from clients (Except HTTP headers)
+          # (%B)
+          #
+          class RequestBytesItem1 < LogItem
+            def get_item(tur)
+              bytes = tur.req.headers.content_length
+              if bytes < 0
+                bytes = 0
+              end
+              return bytes.to_s
+            end
+          end
+
+          #
+          # Return number of bytes that is sent from clients in CLF format (Except
+          # HTTP headers) (%b)
+          #
+          class RequestBytesItem2 < LogItem
+            def get_item(tur)
+              bytes = tur.req.headers.content_length
+              if bytes <= 0
+                return "-"
+              else
+                return bytes.to_s
+              end
+            end
+          end
+
+          #
+          # Return connection status (%c)
+          #
+          class ConnectionStatusItem < LogItem
+            def get_item(tur)
+              if tur.aborted?
+                return "X"
+              else
+                return "-"
+              end
+            end
+          end
+
+          #
+          # Return file name (%f)
+          #
+          class FileNameItem < LogItem
+            def get_item(tur)
+              return tur.req.script_name
+            end
+          end
+
+
+          #
+          # Return remote host name (%H)
+          #
+          class RemoteHostItem < LogItem
+            def get_item(tur)
+              return tur.req.remote_host()
+            end
+          end
+
+          #
+          # Return remote log name (%l)
+          #
+          class RemoteLogItem < LogItem
+            def get_item(tur)
+              return nil
+            end
+          end
+
+          #
+          # Return request protocol (%m)
+          #
+          class ProtocolItem < LogItem
+            def get_item(tur)
+              return tur.req.protocol
+            end
+          end
+
+          #
+          # Return requested header (%{Foobar}i)
+          #
+          class RequestHeaderItem < LogItem
+
+            # Header name
+            attr :name
+
+            def init(param)
+              if param == nil
+                param = ""
+              end
+              @name = param
+            end
+
+            def get_item(tur)
+              return tur.req.headers.get(@name)
+            end
+          end
+
+          #
+          # Return request method (%m)
+          #
+          class MethodItem < LogItem
+            def get_item(tur)
+              return tur.req.method
+            end
+          end
+
+          #
+          # Return responde header (%{Foobar}o)
+          #
+          class ResponseHeaderItem < LogItem
+            # Header name
+            attr :name
+
+            def init(param)
+              if param == nil
+                param = ""
+              end
+              @name = param
+            end
+
+            def get_item(tur)
+              return tur.res.headers.get(@name)
+            end
+          end
+
+
+          #
+          # The server port (%p)
+          #
+          class PortItem < LogItem
+            def get_item(tur)
+              return tur.req.server_port
+            end
+          end
+
+
+          #
+          # Return query string (%q)
+          #
+          class QueryStringItem < LogItem
+            def get_item(tur)
+              qStr = tur.query_string
+              if qStr != nil
+                return '?' + qStr
+              else
+                return ""
+              end
+            end
+          end
+
+          #
+          # The start line (%r)
+          #
+          class StartLineItem < LogItem
+            def get_item(tur)
+              return "#{tur.req.method} #{tur.req.uri} #{tur.req.protocol}"
+            end
+          end
+
+          #
+          # Return status (%s)
+          #
+          class StatusItem < LogItem
+            def get_item(tur)
+              return tur.res.headers.status
+            end
+          end
+
+          #
+          #  Return current time (%{format}t)
+          #
+          class TimeItem < LogItem
+
+            # format
+            attr :format
+
+            def init(param)
+              if param == nil
+                @format  = "[%d/%m/%Y %H:%M:%S %Z]"
+              else
+                @format = param
+              end
+            end
+
+            def get_item(tur)
+              return Time.now.strftime(@format)
+            end
+          end
+
+          #
+          # Return how long request took (%T)
+          #
+          class IntervalItem < LogItem
+            def get_item(tur)
+              return (tur.interval / 1000).to_s
+            end
+          end
+
+          #
+          # Return remote user (%u)
+          #
+          class RemoteUserItem < LogItem
+            def get_item(tur)
+              return tur.req.remote_user
+            end
+          end
+
+          #
+          # Return requested URL(not content query string) (%U)
+          #
+          class RequestUrlItem < LogItem
+            def get_item(tur)
+              url = tur.req.uri== nil ? "" : tur.req.uri
+              pos = url.index('?')
+              if pos != nil
+                url = url[0, pos]
+              end
+              return url
+            end
+          end
+
+          #
+          # Return the server name (%v)
+          #
+          class ServerNameItem < LogItem
+            def get_item(tur)
+              return tur.req.server_name
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'baykit/bayserver/sink'
+require 'baykit/bayserver/taxi/taxi'
+require 'baykit/bayserver/taxi/taxi_runner'
+require 'baykit/bayserver/util/valve'
+require 'baykit/bayserver/util/postman'
+
+module Baykit
+  module BayServer
+    module Docker
+      module BuiltIn
+        class WriteFileTaxi < Baykit::BayServer::Taxi::Taxi
+          include Baykit::BayServer::Util::Valve   # implements
+          include Baykit::BayServer::Util::Postman  # implements
+
+          include Baykit::BayServer::Taxi
+
+          attr :outfile
+          attr :ch_valid
+          attr :data_listener
+          attr :write_queue
+          attr :lock
+
+          def initialize()
+            super
+            @write_queue = []
+            @lock = Mutex.new()
+          end
+
+          def init(out, data_listener)
+            @outfile = out
+            @data_listener = data_listener
+            @ch_valid = true
+          end
+
+          def to_s()
+            return super.to_s + " " + @data_listener.to_s
+          end
+
+          ######################################################
+          # Implements Resumable
+          ######################################################
+          def open_valve()
+            next_run()
+          end
+
+          ######################################################
+          # Implements Taxi
+          ######################################################
+
+          def depart()
+            begin
+              while true
+                buf = nil
+
+                empty = nil
+                @lock.synchronize do
+                  empty = @write_queue.empty?
+                  if !empty
+                    buf = @write_queue[0]
+                    @write_queue.delete_at(0)
+                  end
+                end
+
+                if empty
+                  break
+                end
+
+                @outfile.syswrite(buf)
+
+                empty = nil
+                @lock.synchronize do
+                  empty = @write_queue.empty?
+                end
+
+                if !empty
+                  next_run()
+                end
+              end
+            rescue StandardError => e
+              BayLog.error_e(e)
+            end
+          end
+
+          def post(data, adr, tag)
+            @lock.synchronize do
+              empty = @write_queue.empty?
+              @write_queue.append(data)
+              if empty
+                open_valve()
+              end
+            end
+          end
+
+          def next_run()
+            TaxiRunner.post(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/docker/city.rb

@@ -0,0 +1,22 @@
+require 'baykit/bayserver/docker/docker'
+
+module Baykit
+  module BayServer
+    module Docker
+      module City
+        include Baykit::BayServer::Docker::Docker
+
+        #
+        # interface
+        #
+        #     String name();
+        #     List<Club> clubs();
+        #     List<Town> towns();
+        #     void enter(Tour tour) throws HttpException;
+        #     Trouble getTrouble();
+        #     void log(Tour tour);
+        #
+      end
+    end
+  end
+end