bayserver-core 3.0.2 → 3.3.1

data/lib/baykit/bayserver/agent/transporter/data_listener.rb

@@ -1,38 +0,0 @@
-module Baykit
-  module BayServer
-    module Agent
-      module Transporter
-        module DataListener  # interface
-
-          def notify_connect()
-            raise NotImplementedError.new
-          end
-
-          def notify_handshake_done(protocol)
-            raise NotImplementedError.new
-          end
-
-          def notify_read(buf)
-            raise NotImplementedError.new
-          end
-
-          def notify_eof()
-            raise NotImplementedError.new
-          end
-
-          def notify_protocol_error(err)
-            raise NotImplementedError.new
-          end
-
-          def notify_close()
-            raise NotImplementedError.new
-          end
-
-          def check_timeout(duration_sec)
-            raise NotImplementedError.new
-          end
-        end
-      end
-    end
-  end
-end

data/lib/baykit/bayserver/agent/transporter/spin_read_transporter.rb

@@ -1,111 +0,0 @@
-require 'baykit/bayserver/agent/spin_handler'
-require 'baykit/bayserver/util/string_util'
-require 'baykit/bayserver/util/valve'
-
-module Baykit
-  module BayServer
-    module Agent
-        module Transporter
-          class SpinReadTransporter
-            include Baykit::BayServer::Agent::SpinHandler::SpinListener # implements
-            include Baykit::BayServer::Util::Valve # implements
-            include Baykit::BayServer::Util
-
-            attr :spin_handler
-            attr :data_listener
-            attr :infile
-            attr :read_buf
-            attr :total_read
-            attr :file_len
-            attr :timeout_sec
-            attr :eof_checker
-            attr :is_closed
-
-            def initialize(buf_size)
-              @read_buf = StringUtil.alloc(buf_size)
-            end
-
-            def init(spin_hnd, lis, infile, limit, timeout_sec, eof_checker)
-              @spin_handler = spin_hnd
-              @data_listener = lis
-              @infile = infile
-              @file_len = limit
-              @total_read = 0
-              @timeout_sec = timeout_sec
-              @eof_checker = eof_checker
-              @is_closed = false
-            end
-
-            def to_s
-              data_listener.to_s()
-            end
-
-            ######################################################
-            # Implements Reusable
-            ######################################################
-
-            def reset()
-              @data_listener = nil
-              @infile = nil
-            end
-
-            ######################################################
-            # Implements SpinListener
-            ######################################################
-
-            def lap()
-              begin
-                @infile.sysread(@buf_size, @read_buf)
-
-                if @read_buf.length == 0
-                  return NextSocketAction::CONTINUE, true
-                end
-                @total_read += @read_buf.length
-
-                next_act = @yacht.notify_read(@read_buf)
-
-                if @total_read == @file_len
-                  @data_listener.notify_eof()
-                  close()
-                  return NextSocketAction::CLOSE, false
-                end
-
-                return next_act, false
-              rescue Exception => e
-                BayLog.error_e(e)
-                close()
-                return NextSocketAction::CLOSE, false
-              end
-            end
-
-            def check_timeout(duration_sec)
-              return duration_sec > @timeout_sec
-            end
-
-            def close()
-              if @infile != nil
-                @infile.close()
-              end
-              @data_listener.notify_close()
-              @is_closed = true
-            end
-
-            ######################################################
-            # Implements Valve
-            ######################################################
-
-            def open_valve()
-              @spin_handler.ask_to_callback(self)
-            end
-
-            ######################################################
-            # Other methods
-            ######################################################
-
-
-          end
-
-        end
-    end
-  end
-end

data/lib/baykit/bayserver/agent/transporter/spin_write_transporter.rb

@@ -1,125 +0,0 @@
-require 'baykit/bayserver/agent/spin_handler'
-require 'baykit/bayserver/util/string_util'
-require 'baykit/bayserver/util/reusable'
-require 'baykit/bayserver/util/valve'
-require 'baykit/bayserver/util/postman'
-
-module Baykit
-  module BayServer
-    module Agent
-        module Transporter
-          class SpinWriteTransporter < Baykit::BayServer::Agent::SpinHandler
-            include Baykit::BayServer::Util::Valve # implements
-            include Baykit::BayServer::Util::Reusable # implements
-            include Baykit::BayServer::Util::Postman # implements
-
-            include Baykit::BayServer::Util
-
-            attr :spin_handler
-            attr :data_listener
-            attr :outfile
-            attr :write_queue
-            attr :lock
-
-
-            def initialize()
-              @write_queue = []
-              @lock = Mutex.new()
-            end
-
-            def init(spin_hnd, outfile, lis)
-              @spin_handler = spin_hnd
-              @data_listener = lis
-              @outfile = outfile
-            end
-
-            def to_s
-              data_listener.to_s()
-            end
-
-            ######################################################
-            # Implements Reusable
-            ######################################################
-
-            def reset()
-              @data_listener = nil
-              @outfile = nil
-            end
-
-            ######################################################
-            # Implements SpinListener
-            ######################################################
-
-            def lap()
-              begin
-
-                buf = nil
-                @lock.synchronize do
-                  if @write_queue.empty?
-                    BayLog.warn("%s Write queue empty", self)
-                    return NextSocketAction::SUSPEND
-                  end
-                  buf = @write_queue[0]
-                end
-
-                len = @outfile.syswrite(buf)
-
-                if len == 0
-                  return NextSocketAction::CONTINUE
-                elsif len < buf.length
-                  buf[0 .. len-1] = ""
-                  return NextSocketAction::CONTINUE
-                end
-
-                @lock.synchronize do
-                  @write_queue.delete_at(0)
-                  if @write_queue.empty?
-                    return NextSocketAction::SUSPEND
-                  else
-                    return NextSocketAction::CONTINUE
-                  end
-                end
-
-              rescue Exception => e
-                BayLog.error_e(e)
-                close()
-                return NextSocketAction::CLOSE
-              end
-            end
-
-            def check_timeout(duration_sec)
-              return false
-            end
-
-            def close()
-              if @outfile != nil
-                @outfile.close()
-              end
-            end
-
-            ######################################################
-            # Implements Valve
-            ######################################################
-
-            def open_valve()
-              @spin_handler.ask_to_callback(self)
-            end
-
-            ######################################################
-            # Other methods
-            ######################################################
-            def post(bytes, tag)
-              @lock.synchronize do
-                empty = @write_queue.empty?
-                @write_queue << bytes
-                if empty
-                  open_valve()
-                end
-              end
-            end
-
-          end
-        end
-    end
-  end
-end

data/lib/baykit/bayserver/agent/transporter/transporter.rb

@@ -1,332 +0,0 @@
-require 'baykit/bayserver/agent/non_blocking_handler'
-require 'baykit/bayserver/agent/channel_listener'
-require 'baykit/bayserver/protocol/protocol_exception'
-require 'baykit/bayserver/util/reusable'
-require 'baykit/bayserver/util/postman'
-
-module Baykit
-  module BayServer
-    module Agent
-        module Transporter
-          class Transporter
-            include Baykit::BayServer::Agent::ChannelListener # implements
-            include Baykit::BayServer::Util::Reusable # implements
-            include Baykit::BayServer::Util::Postman  # implements
-
-            include Baykit::BayServer::Protocol
-            include Baykit::BayServer::Util
-
-            #
-            # Abstract methods
-            #
-            def secure()
-              raise NotImplementedError.new
-            end
-
-            def handshake_nonblock()
-              raise NotImplementedError.new
-            end
-
-            def handshake_finished()
-              raise NotImplementedError.new
-            end
-
-            attr :data_listener
-            attr :infile
-            attr :write_queue
-            attr :finale
-            attr :initialized
-            attr :ch_valid
-            attr :read_buf
-            attr :socket_io
-            attr :handshaked
-            attr :lock
-            attr :capacity
-            attr :non_blocking_handler
-            attr :write_only
-
-            def initialize(server_mode, bufsiz, trace_ssl, write_only = false)
-              @server_mode = server_mode
-              @write_queue = []
-              @lock = ::Monitor.new()
-              @capacity = bufsiz
-              @read_buf = StringUtil.alloc(bufsiz)
-              @trace_ssl = trace_ssl
-              reset()
-              @write_only = write_only
-            end
-
-            def to_s()
-              return "tpt[#{@data_listener.to_s}]"
-            end
-
-
-            ######################################################
-            # Implements Reusable
-            ######################################################
-            def reset()
-
-              # Check write queue
-              if !@write_queue.empty?
-                raise Sink.new("Write queue is not empty")
-              end
-
-              @finale = false
-              @initialized = false
-              @ch = nil
-              set_valid(false)
-              @handshaked = false
-              @socket_io = nil
-              @read_buf.clear()
-              @write_only = false
-            end
-
-            ######################################################
-            # Implements Postman
-            ######################################################
-
-            def post(buf, adr, tag, &lisnr)
-              check_initialized()
-
-              BayLog.debug("%s post: %s len=%d", self, tag, buf.length)
-
-
-            end
-
-            ######################################################
-            # Implements Valve
-            ######################################################
-
-            def open_valve()
-              BayLog.debug("%s resume", self)
-              @channel_handler.ask_to_read(@ch)
-            end
-
-            def abort()
-              BayLog.debug("%s abort", self)
-              @channel_handler.ask_to_close(@ch)
-            end
-
-            def zombie?()
-              return @ch != nil && !@ch_valid
-            end
-
-
-            ######################################################
-            # Implements ChannelListener
-            ######################################################
-
-            def on_readable(chk_ch)
-              check_channel(chk_ch)
-            end
-
-            def on_writable(chk_ch)
-              check_channel(chk_ch)
-
-              BayLog.trace("%s Writable", self)
-
-              if !@handshaked
-                begin
-                  handshake_nonblock
-                  BayLog.debug("#{@ship} Handshake done")
-                  @handshaked = true
-                rescue IO::WaitReadable => e
-                  BayLog.debug("#{@ship} Handshake status: read more")
-                  return NextSocketAction::READ
-                rescue IO::WaitWritable => e
-                  BayLog.debug("#{@ship} Handshake status: write more")
-                  return NextSocketAction::CONTINUE
-                rescue StandardError => e
-                  BayLog.error_e(e, " Error on handshaking: %s", self, e);
-                  set_valid(false)
-                  return NextSocketAction::CLOSE
-                end
-              end
-
-              if !@ch_valid
-                return NextSocketAction::CLOSE
-              end
-
-              empty = false
-              while true
-                #BayLog.debug "#{self} Send queue len=#{@write_queue.length}"
-                wunit = nil
-                @lock.synchronize do
-                  if @write_queue.empty?
-                    empty = true
-                    break
-                  end
-                  wunit = @write_queue[0]
-                end
-
-                if empty
-                  break
-                end
-
-                BayLog.debug("%s Try to write: pkt=%s buflen=%d chValid=%s", self, wunit.tag, wunit.buf.length, @ch_valid)
-
-                if @ch_valid && wunit.buf.length > 0
-                  begin
-                    len = write_nonblock(wunit.buf, wunit.adr)
-                    wunit.buf[0, len] = ""
-                    if wunit.buf.length > 0
-                      # Data remains
-                      break
-                    end
-                  rescue IO::WaitWritable => e
-                    BayLog.debug_e(e, "%s Write will be pended", self)
-                    break
-                  end
-                end
-
-                # packet send complete
-                wunit.done()
-
-                @lock.synchronize do
-                  @write_queue.delete_at(0)
-                  empty = @write_queue.empty?
-                end
-
-                if empty
-                  break
-                end
-              end
-
-              if empty
-                if @finale
-                  BayLog.trace("%s finale return Close", self)
-                  state = NextSocketAction::CLOSE
-                elsif @write_only
-                  state = NextSocketAction::SUSPEND
-                else
-                  state = NextSocketAction::READ # will be handled as "Write Off"
-                end
-              else
-                state = NextSocketAction::CONTINUE
-              end
-
-              return state
-            end
-
-
-            def on_connectable(chk_ch)
-              check_channel(chk_ch)
-              BayLog.trace("%s onConnectable", self)
-
-              # check connected
-              begin
-                buf = ""
-                @ch.syswrite(buf)
-              rescue => e
-                BayLog.error("Connect failed: %s", e)
-                return NextSocketAction::CLOSE
-              end
-
-              return @data_listener.notify_connect()
-            end
-
-            def check_timeout(chk_ch, duration)
-              check_channel(chk_ch)
-
-              return @data_listener.check_timeout(duration)
-            end
-
-            def on_error(chk_ch, e)
-              check_channel(chk_ch)
-              BayLog.trace("%s onError: %s", self, e)
-
-              begin
-                raise e
-              rescue OpenSSL::SSL::SSLError => e
-                if @trace_ssl
-                  BayLog.error_e(e, "%s SSL Error: %s", self, e)
-                else
-                  BayLog.debug_e(e, "%s SSL Error: %s", self, e)
-                end
-              rescue => e
-                BayLog.error_e(e)
-              end
-            end
-
-            def on_closed(chk_ch)
-              begin
-                check_channel(chk_ch)
-              rescue => e
-                BayLog.error_e(e)
-                return
-              end
-
-              set_valid(false)
-
-              @lock.synchronize do
-                # Clear queue
-                @write_queue.each do |write_unit|
-                  write_unit.done()
-                end
-                @write_queue.clear()
-              end
-              @data_listener.notify_close()
-            end
-
-            def flush()
-              check_initialized()
-
-              BayLog.debug("%s flush", self)
-
-              if @ch_valid
-                empty = false
-                @lock.synchronize do
-                  empty = @write_queue.empty?
-                end
-
-                if !empty
-                  BayLog.debug("%s flush->askToWrite", self)
-                  @channel_handler.ask_to_write(@ch)
-                end
-              end
-            end
-
-            def post_end()
-              check_initialized()
-
-              BayLog.debug("%s postEnd vld=%s", self, self.ch_valid)
-
-              # setting order is QUITE important  finalState->finale
-              @finale = true
-
-              if @ch_valid
-                empty = nil
-                @lock.synchronize do
-                  empty = @write_queue.empty?
-                end
-
-                if !empty
-                  BayLog.debug("%s Tpt: sendEnd->askToWrite", self)
-                  @channel_handler.ask_to_write(@ch)
-                end
-              end
-            end
-
-            protected
-            def check_channel(chk_ch)
-              if chk_ch != @ch
-                raise Sink.new("Invalid transporter instance (ship was returned?): #{chk_ch}")
-              end
-            end
-
-            def check_initialized
-              if !@initialized
-                raise Sink.new("Illegal State")
-              end
-            end
-
-            def set_valid(valid)
-              @ch_valid = valid
-            end
-
-          end
-        end
-    end
-  end
-end
-

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

@@ -1,71 +0,0 @@
-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
-