bayserver-core 2.3.2 → 3.0.1

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

@@ -0,0 +1,30 @@
+module Baykit
+  module BayServer
+    module Agent
+      class Letter
+        ACCEPTED = 1
+        CONNECTED = 2
+        READ = 3
+        WROTE = 4
+        CLOSEREQ = 5
+
+        attr :type
+        attr :state
+        attr :n_bytes
+        attr :address
+        attr :err
+        attr :client_rudder
+
+        def initialize(type, st, client_rd, n, adr, err)
+          @type = type
+          @state = st
+          @client_rudder = client_rd
+          @n_bytes = n
+          @err = err
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -2,13 +2,15 @@
 module Baykit
   module BayServer
     module Agent
-      module LifecycleListener
-        #
-        # interface
-        #
-        #             void add(int agentId);
-        #             void remove(int agentId);
-        #
+      module LifecycleListener # interface
+
+        def add(agent_id)
+          raise NotImplementedError
+        end
+
+        def remove(agent_id)
+          raise NotImplementedError
+        end
       end
     end
   end

data/lib/baykit/bayserver/agent/monitor/grand_agent_monitor.rb

@@ -0,0 +1,298 @@
+require 'fcntl'
+require 'baykit/bayserver/agent/grand_agent'
+require 'baykit/bayserver/rudders/io_rudder'
+require 'baykit/bayserver/util/io_util'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Monitor
+        class GrandAgentMonitor
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Rudders
+
+          class << self
+            attr :num_agents
+            attr :cur_id
+            attr :anchored_port_map
+            attr :monitors
+            attr :finale
+          end
+
+          @num_agents = 0
+          @cur_id = 0
+          @anchored_port_map = []
+          @monitors = {}
+          @finale = false
+
+          attr :agent_id
+          attr :anchorable
+          attr :rudder
+          attr :child_thread
+          attr :child_pid
+
+          def initialize(agt_id, anchorable, rd, child_thread, child_pid)
+            @agent_id = agt_id
+            @anchorable = anchorable
+            @rudder = rd
+            @child_thread = child_thread
+            @child_pid = child_pid
+          end
+
+          def to_s()
+            return "Monitor##{@agent_id}"
+          end
+
+          def run()
+            begin
+              while true do
+                buf = " " * 4
+
+                n = @rudder.read(buf, 4)
+                if n == -1
+                  raise EOFError.new
+                end
+                if n < 4
+                  raise IOError.new("Cannot read int: nbytes=#{n}")
+                end
+                res = buffer_to_int(buf)
+                if res == GrandAgent::CMD_CLOSE
+                  BayLog.debug("%s read Close", self)
+                  break
+                elsif res == GrandAgent::CMD_CATCHUP
+                  on_read_catch_up
+                else
+                  BayLog.debug("%s read OK: %d", self, res);
+                end
+
+              end
+            rescue EOFError, IOError => e
+              BayLog.fatal("Agent terminated")
+            rescue Exception => e
+              BayLog.fatal_e(e)
+            end
+          end
+
+          def on_readable()
+            begin
+              res = IOUtil.read_int32(@communication_channel)
+              if res == nil || res == GrandAgent::CMD_CLOSE
+                close()
+              else
+                BayLog.debug("%s read OK: %d", self, res)
+              end
+            rescue IO::WaitReadable
+              #BayLog.debug("%s no data", self)
+            end
+          end
+
+          def shutdown()
+            BayLog.debug("%s send shutdown command", self)
+            send(GrandAgent::CMD_SHUTDOWN)
+          end
+
+          def abort()
+            BayLog.debug("%s Send abort command", self)
+            send(GrandAgent::CMD_ABORT)
+          end
+
+          def reload_cert()
+            BayLog.debug("%s Send reload command", self)
+            send(GrandAgent::CMD_RELOAD_CERT)
+          end
+
+          def print_usage()
+            BayLog.debug("%s Send mem_usage command", self)
+            send(GrandAgent::CMD_MEM_USAGE)
+            sleep(0.5)  # Lazy implementation
+          end
+
+          def send(cmd)
+            BayLog.debug("%s send command %s rd=%s", self, cmd, @rudder)
+            buf = GrandAgentMonitor.int_to_buffer(cmd)
+            @rudder.write(buf)
+          end
+
+          def close()
+            @rudder.close()
+          end
+
+          def on_read_catch_up()
+
+          end
+          def req_catch_up()
+
+          end
+
+          def agent_aborted()
+            BayLog.info(BayMessage.get(:MSG_GRAND_AGENT_SHUTDOWN, @agent_id))
+
+            if @child_pid != nil
+              begin
+                Process.kill("TERM", @child_pid)
+              rescue => e
+                BayLog.debug_e(e, "Error on killing process")
+              end
+              Process.wait(@child_pid)
+            end
+            GrandAgentMonitor.monitors.delete(@agent_id)
+
+            if not GrandAgentMonitor.finale
+              if GrandAgentMonitor.monitors.length < GrandAgentMonitor.num_agents
+                begin
+                  if !BayServer.harbor.multi_core
+                    GrandAgent.add(-1, @anchorable)
+                  end
+                  GrandAgentMonitor.add(@anchorable)
+                rescue => e
+                  BayLog.error_e(e)
+                end
+              end
+            end
+          end
+
+          def start
+            @child_thread = Thread.new do
+              run()
+            end
+          end
+
+          ########################################
+          # Class methods
+          ########################################
+
+          def self.init(num_agents, anchored_port_map)
+            @num_agents = num_agents
+            @anchored_port_map = anchored_port_map
+            @num_agents.times do
+              add(true)
+            end
+          end
+
+          def self.add(anchoroable)
+            @cur_id = @cur_id + 1
+            agt_id = @cur_id
+            if agt_id > 100
+              BayLog.error("Too many agents started")
+              exit(1)
+            end
+
+            if BayServer.harbor.multi_core
+              new_argv = BayServer.commandline_args.dup
+              new_argv.insert(0, "ruby")
+              new_argv << "-agentid=" + agt_id.to_s
+
+              ports = ""
+
+              no_close_io = {}  # Port list not to close on spawned
+              @anchored_port_map.each_key do |ch|
+                no_close_io[ch] = ch
+                if ports != ""
+                  ports +=","
+                end
+                ports += ch.fileno.to_s
+              end
+              new_argv << "-ports=" + ports
+
+              server = TCPServer.open("localhost", 0)
+              #BayLog.info("port=%d", server.local_address.ip_port)
+              new_argv << "-monitor_port=" + server.local_address.ip_port.to_s
+
+              if SysUtil.run_on_windows()
+                child_pid = spawn(ENV, new_argv.join(" "))
+              else
+                child_pid = spawn(ENV, new_argv.join(" "), no_close_io)
+              end
+
+              BayLog.debug("Process spawned cmd=%s pid=%d", new_argv, child_pid)
+
+              client_socket = server.accept()
+              server.close()
+
+            else
+
+              if SysUtil::run_on_windows()
+                pair = Socket.socketpair(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+              else
+                pair = Socket.socketpair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+              end
+
+              client_socket = pair[0]
+              GrandAgent.add(agt_id, anchoroable)
+
+              # Agents run on single core (thread mode)
+              child_thread = Thread.new() do
+                agt = GrandAgent.get(agt_id)
+                agt.add_command_receiver(IORudder.new(pair[1]))
+                agt.start()
+              end
+
+            end
+
+            mon =
+              GrandAgentMonitor.new(
+                agt_id,
+                anchoroable,
+                IORudder.new(client_socket),
+                child_thread,
+                child_pid)
+            @monitors[agt_id] = mon
+            mon.start
+
+          end
+
+          def self.join
+            while !@monitors.empty?
+              @monitors.values.each do |mon|
+                mon.child_thread.join
+                mon.agent_aborted
+              end
+            end
+          end
+          def self.reload_cert_all()
+            @monitors.values.each { |mon| mon.reload_cert() }
+          end
+
+          def self.restart_all()
+            old_monitors = @monitors.dup()
+
+            #@agent_count.times {add()}
+
+            old_monitors.values.each { |mon| mon.shutdown() }
+          end
+
+          def self.shutdown_all()
+            @finale = true
+            @monitors.dup().values.each do |mon|
+              mon.shutdown()
+            end
+          end
+
+          def self.abort_all()
+            @finale = true
+            @monitors.dup().values.each do |mon|
+              mon.abort()
+            end
+            exit(1)
+          end
+
+          def self.print_usage_all()
+            @monitors.values.each do |mon|
+              mon.print_usage()
+            end
+          end
+
+          def self.buffer_to_int(buf)
+            return buf.unpack("N").first
+          end
+
+          def self.int_to_buffer(val)
+            return [val].pack("N")
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/agent/multiplexer/job_multiplexer.rb

@@ -0,0 +1,257 @@
+require 'baykit/bayserver/rudders/io_rudder'
+
+require 'baykit/bayserver/agent/multiplexer/multiplexer_base'
+require 'baykit/bayserver/agent/multiplexer/job_multiplexer_base'
+
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class JobMultiplexer < JobMultiplexerBase
+          include Baykit::BayServer::Agent::TimerHandler #implements
+          include Baykit::BayServer::Common::Recipient  # implements
+          include Baykit::BayServer::Agent::Multiplexer
+
+          include Baykit::BayServer::Rudders
+          include Baykit::BayServer::Util
+
+          def initialize(agt, anchorable)
+            super
+          end
+          def to_s
+            return "JobMpx[#{@agent}]"
+          end
+
+
+          #########################################
+          # Implements Multiplexer
+          #########################################
+
+          def req_accept(rd)
+            BayLog.debug("%s reqAccept isShutdown=%s", @agent, @agent.aborted)
+            if @agent.aborted
+              return
+            end
+
+            st = get_rudder_state(rd)
+
+            Thread.new do
+              begin
+                if @agent.aborted
+                  next
+                end
+
+                begin
+                  client_skt, adr = rd.io.accept
+                rescue Exception => e
+                  @agent.send_accepted_letter(st, nil, e, true)
+                  next
+                end
+
+                BayLog.debug("%s Accepted skt=%s", @agent, client_skt)
+                if agent.aborted
+                  BayLog.error("%s Agent is not alive (close)", @agent);
+                  client_skt.close
+                else
+                  @agent.send_accepted_letter(st, IORudder.new(client_skt), nil, true)
+                end
+
+              rescue Exception => e
+                BayLog.fatal_e(e)
+                @agent.shutdown
+              end
+            end
+
+          end
+
+
+          def req_connect(rd, adr)
+            st = get_rudder_state(rd)
+            BayLog.debug("%s reqConnect adr=%s rd=%s chState=%s", @agent, adr.canonname, rd, st)
+
+            Thread.new do
+              begin
+                rd.io.connect(adr)
+                BayLog.debug("%s Connected rd=%s", @agent, rd)
+                @agent.send_connected_letter(st, nil, false)
+              rescue Exception => e
+                @agent.send_connected_letter(st, e, false)
+                return
+              end
+            end
+
+            st.connecting = true
+          end
+
+          def req_read(rd)
+            st = get_rudder_state(rd)
+            if st == nil
+              return
+            end
+
+            BayLog.debug("%s reqRead rd=%s state=%s", @agent, st.rudder, st);
+            need_read = false
+            st.reading_lock.synchronize do
+              if !st.reading
+                need_read = true
+                st.reading = true
+              end
+            end
+
+            if need_read
+              next_read(st)
+            end
+
+            st.access
+          end
+
+          def req_write(rd, buf, adr, tag, lis)
+            st = get_rudder_state(rd)
+            BayLog.debug("%s reqWrite st=%s", @agent, st)
+
+            if st == nil || st.closed
+              BayLog.warn("%s Channel is closed: %s", @agent, rd)
+              return
+            end
+
+            unt = WriteUnit.new(buf, adr, tag, lis)
+            st.writing_lock.synchronize do
+              st.write_queue << unt
+            end
+
+            need_write = false
+            st.writing_lock.synchronize do
+              if !st.writing
+                need_write = true
+                st.writing = true
+              end
+            end
+
+            if need_write
+              next_write(st)
+            end
+
+            st.access
+          end
+
+          def req_close(rd)
+            st = get_rudder_state(rd)
+            BayLog.debug("%s reqClose st=%s", @agent, st);
+
+            if st == nil
+              BayLog.warn("%s channel state not found: %s", @agent, rd)
+              return
+            end
+
+            Thread.new do
+              begin
+                st = get_rudder_state(rd)
+                if st == nil
+                  BayLog.debug("%s Rudder is already closed: rd=%s", @agent, rd)
+                  next
+                end
+
+                close_rudder(st)
+              rescue Exception => e
+                BayLog.fatal_e(e)
+                @agent.shutdown
+              end
+            end
+
+            st.access
+          end
+
+          def cancel_read(st)
+
+          end
+
+          def cancel_write(st)
+
+          end
+
+          def next_accept(st)
+            req_accept(st.rudder)
+          end
+
+          def next_read(st)
+            Thread.new do
+              if st.closed
+                #channel is already closed
+                BayLog.debug("%s Rudder is already closed: rd=%s", @agent, st.rudder);
+                next
+              end
+
+              begin
+                if st.handshaking
+                  # Calls accept API for client socket
+                  st.rudder.io.accept
+                  st.handshaking = false
+
+                  BayLog.debug("%s Handshake done (rd=%s)", self, st.rudder)
+                  app_protocols = st.rudder.io.context.alpn_protocols
+
+                  # HELP ME
+                  #   This code does not work!
+                  #   We cannot get application protocol name
+                  proto = nil
+                  if app_protocols != nil && app_protocols.length > 0
+                    proto = app_protocols[0]
+                  end
+                end
+
+                BayLog.debug("%s Try to Read (rd=%s)", @agent, st.rudder)
+                begin
+                  n = st.rudder.read(st.read_buf, st.buf_size)
+                rescue EOFError => e
+                  n = 0
+                  st.read_buf.clear
+                end
+
+                @agent.send_read_letter(st, n, nil, nil, true)
+
+              rescue Exception => e
+                @agent.send_read_letter(st, -1, nil, e, true)
+              end
+            end
+          end
+
+          def next_write(st)
+            Thread.new do
+              BayLog.debug("%s next write st=%s", @agent, st)
+
+              if st == nil || st.closed
+                BayLog.warn("%s Channel is closed: %s", @agent, st.rudder)
+                next
+              end
+
+              u = st.write_queue[0]
+              BayLog.debug("%s Try to write: pkt=%s buflen=%d closed=%s", self, u.tag, u.buf.length, st.closed);
+
+              n = 0
+              begin
+                if !st.closed && u.buf.length > 0
+                  n = st.rudder.write(u.buf)
+                  u.buf.slice!(0, n)
+                end
+              rescue Exception => e
+                @agent.send_wrote_letter(st, -1, e, true)
+                next
+              end
+
+              @agent.send_wrote_letter(st, n, nil, true)
+            end
+          end
+
+          def is_non_blocking()
+            return false
+          end
+
+          def use_async_api()
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/multiplexer/job_multiplexer_base.rb

@@ -0,0 +1,52 @@
+
+module Baykit
+  module BayServer
+    module Agent
+      module Multiplexer
+        class JobMultiplexerBase < MultiplexerBase
+          include TimerHandler
+
+          attr :anchorable
+          attr :pipe
+
+          def initialize(agt, anchorable)
+            super(agt)
+
+            @anchorable = anchorable
+            @agent.add_timer_handler(self)
+
+            @pipe = IO::pipe
+          end
+
+          #########################################
+          # Implements Multiplexer
+          #########################################
+
+          def shutdown()
+            close_all()
+          end
+
+          def on_free()
+            if @agent.aborted
+              return
+            end
+
+            if @anchorable
+              BayServer::anchorable_port_map.keys.each do |rd|
+                req_accept(rd)
+              end
+            end
+          end
+
+          #########################################
+          # Implements TimerHandler
+          #########################################
+
+          def on_timer()
+            close_timeout_sockets()
+          end
+        end
+      end
+    end
+  end
+end