bayserver-core 2.2.0

data/lib/baykit/bayserver/agent/signal/signal_agent.rb

@@ -0,0 +1,165 @@
+require 'baykit/bayserver/mem_usage'
+require 'baykit/bayserver/bcf/package'
+
+require 'baykit/bayserver/agent/grand_agent_monitor'
+require 'baykit/bayserver/agent/signal/signal_proxy'
+require 'baykit/bayserver/util/sys_util'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Signal
+        class SignalAgent
+          include Baykit::BayServer
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Util
+          include Baykit::BayServer::Agent
+          include Baykit::BayServer::Agent::Signal
+
+          COMMAND_RELOAD_CERT = "reloadcert"
+          COMMAND_MEM_USAGE = "memusage"
+          COMMAND_RESTART_AGENTS = "restartagents"
+          COMMAND_SHUTDOWN = "shutdown"
+          COMMAND_ABORT = "abort"
+
+          class << self
+            attr :commands
+            attr :signal_map
+            attr :signal_agent
+          end
+
+          @commands = [
+            COMMAND_RELOAD_CERT,
+            COMMAND_MEM_USAGE,
+            COMMAND_RESTART_AGENTS,
+            COMMAND_SHUTDOWN,
+            COMMAND_ABORT
+          ]
+          @signal_map = {}
+          @signal_agent = nil
+
+          attr :port
+          attr :server_skt
+
+          def initialize(port)
+            @port = port
+            @server_skt = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+            @server_skt.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+            adr = Socket.sockaddr_in(@port, "127.0.0.1")
+            @server_skt.bind(adr)
+            @server_skt.listen(0)
+            BayLog.info( BayMessage.get(:MSG_OPEN_CTL_PORT, @port))
+          end
+
+          def on_socket_readable()
+
+            begin
+              skt, = @server_skt.accept
+              skt.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [5, 0].pack("l_2"))
+
+              line = skt.readline.strip()
+              BayLog.info(BayMessage.get(:MSG_COMMAND_RECEIVED, line))
+              SignalAgent.handle_command(line)
+              skt.write("OK\n")
+              skt.flush
+
+            rescue => e
+              BayLog.error_e(e)
+
+            ensure
+              if skt
+                skt.close()
+              end
+            end
+
+          end
+
+          def close
+            @server_skt.close
+          end
+
+
+          ######################################################
+          # class methods
+          ######################################################
+
+          def SignalAgent.init(bay_port)
+            @commands.each do |cmd|
+              SignalProxy.register(get_signal_from_command(cmd)) do
+                handle_command(cmd)
+              end
+            end
+
+            if bay_port > 0
+              @signal_agent = SignalAgent.new(bay_port)
+            end
+          end
+
+          def SignalAgent.handle_command(cmd)
+            BayLog.debug("handle command: %s", cmd)
+            case (cmd.downcase)
+            when COMMAND_RELOAD_CERT
+              GrandAgentMonitor::reload_cert_all()
+            when COMMAND_MEM_USAGE
+              GrandAgentMonitor::print_usage_all()
+            when COMMAND_RESTART_AGENTS
+              GrandAgentMonitor::restart_all()
+            when COMMAND_SHUTDOWN
+              GrandAgentMonitor::shutdown_all()
+            when COMMAND_ABORT
+              GrandAgentMonitor::abort_all()
+            else
+              BayLog.error("Unknown command: %s", cmd)
+            end
+          end
+
+
+          def SignalAgent.get_signal_from_command(command)
+            init_signal_map()
+            @signal_map.keys().each do |sig|
+              if(@signal_map[sig].casecmp?(command))
+                return sig;
+              end
+            end
+            return nil
+          end
+
+          def SignalAgent.init_signal_map()
+            if !@signal_map.empty?
+              return;
+            end
+
+            if SysUtil.run_on_windows()
+              # Available signals on Windows
+              #    SIGABRT
+              #    SIGFPE
+              #    SIGILL
+              #    SIGINT
+              #    SIGSEGV
+              #    SIGTERM
+              @signal_map["SEGV"] = COMMAND_RELOAD_CERT
+              @signal_map["ILL"] = COMMAND_MEM_USAGE
+              @signal_map["INT"] = COMMAND_SHUTDOWN
+              @signal_map["TERM"] = COMMAND_RESTART_AGENTS
+              @signal_map["ABRT"] = COMMAND_ABORT
+
+            else
+              @signal_map["ALRM"] = COMMAND_RELOAD_CERT
+              @signal_map["TRAP"] = COMMAND_MEM_USAGE
+              @signal_map["HUP"] = COMMAND_RESTART_AGENTS
+              @signal_map["TERM"] = COMMAND_SHUTDOWN
+              @signal_map["ABRT"] = COMMAND_ABORT
+            end
+          end
+
+          def SignalAgent.term()
+            if @signal_agent
+              @signal_agent.close()
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/agent/signal/signal_proxy.rb

@@ -0,0 +1,18 @@
+module Baykit
+  module BayServer
+    module Agent
+      module Signal
+        class SignalProxy
+
+          def SignalProxy.register(sig, &handler)
+            begin
+              ::Signal.trap(sig, proc {handler.call()})
+            rescue ArgumentError => e
+              BayLog.warn(BayMessage.get(:INT_CANNOT_SET_SIG_HANDLER, e.message, sig))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/agent/signal/signal_sender.rb

@@ -0,0 +1,99 @@
+require 'baykit/bayserver/bcf/bcf_parser'
+require 'baykit/bayserver/bay_log'
+require 'baykit/bayserver/docker/built_in/built_in_harbor_docker'
+require 'baykit/bayserver/util/sys_util'
+
+module Baykit
+  module BayServer
+    module Agent
+      module Signal
+        class SignalSender
+          include Baykit::BayServer::Bcf
+          include Baykit::BayServer::Docker::BuiltIn
+          include Baykit::BayServer::Util
+
+
+          attr :control_port
+          attr :pid_file
+
+          def initialize
+            @bay_port = BuiltInHarborDocker::DEFAULT_CONTROL_PORT
+            @pid_file = BuiltInHarborDocker::DEFAULT_PID_FILE
+          end
+
+
+          #
+          # Send running BayServer a command
+          #
+          def send_command(cmd)
+            parse_bay_port(BayServer.bserv_plan)
+
+            if @bay_port < 0
+              pid = read_pid_file()
+              sig = SignalAgent.get_signal_from_command(cmd)
+              if sig == nil
+                raise StandardError("Invalid command: " + cmd)
+              else
+                kill(pid, sig)
+              end
+            else
+              BayLog.info(BayMessage.get(:MSG_SENDING_COMMAND, cmd))
+              send("127.0.0.1", @bay_port, cmd)
+            end
+          end
+
+          #
+          # Parse plan file and get port number of SignalAgent
+          #
+          def parse_bay_port(plan)
+            p = BcfParser.new()
+            doc = p.parse(plan)
+            doc.content_list.each do |elm|
+              if elm.kind_of?(BcfElement)
+                if elm.name.casecmp?("harbor")
+                  elm.content_list.each do |kv|
+                    if kv.key.casecmp?("controlPort")
+                      @bay_port = kv.value.to_i()
+                    elsif kv.key.casecmp?("pidFile")
+                      @pid_file = kv.value
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+
+          def send(host, port, cmd)
+            begin
+              a = Addrinfo.tcp(host, port)
+              s = Socket.new(a.ipv4? ? Socket::AF_INET : Socket::AF_INET6, Socket::SOCK_STREAM)
+              s.connect(a)
+              s.write(cmd + "\n")
+              s.flush();
+              line = s.readline()
+            ensure
+              s.close()
+            end
+          end
+
+          def kill(pid, sig)
+            BayLog.info("Send signal pid=#{pid} sig=#{sig}")
+            if SysUtil.run_on_windows()
+              system("taskkill /PID #{pid} /F")
+            else
+              Process.kill(sig, pid)
+            end
+          end
+
+          def read_pid_file()
+            File.open(BayServer.get_location(@pid_file), "r") do |f|
+              return f.readline().to_i()
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,140 @@
+
+module Baykit
+  module BayServer
+    module Agent
+      class SpinHandler
+
+        module SpinListener
+          #
+          # interface
+          #
+          #         NextSocketAction lap(boolean spun[]);
+          #         boolean checkTimeout(int durationSec);
+          #         void close();
+          #
+        end
+
+        class ListenerInfo
+          attr :listener
+          attr :last_access
+
+          def initialize(lis, last_access)
+            @listener = lis
+            @last_access = last_access
+          end
+        end
+
+
+        attr :listeners
+        attr :lock
+        attr :agent
+        attr :spin_count
+
+        def initialize(agt)
+          @listeners = []
+          @lock = Mutex.new
+          @agent = agt
+          @spin_count = 0
+        end
+
+        def to_s()
+          return @agent.to_s()
+        end
+
+        def process_data()
+          if @listeners.empty?
+            return false
+          end
+
+          all_spun = true
+          remove_list = []
+          @listeners.length.downto(1) do |i|
+            lis = listeners[i-1].listener
+            act, spun = lis.lap()
+
+            case act
+            when NextSocketAction::SUSPEND
+              remove_list.append(i-1)
+            when NextSocketAction::CLOSE
+              remove_list.append(i-1)
+            when NextSocketAction::CONTINUE
+              next
+            else
+              raise Sink.new()
+            end
+
+            @listeners[i].last_access = Time.now.tv_sec()
+            all_spun = all_spun & spun
+          end
+
+          if all_spun
+            @spin_count += 1
+            if @spin_count > 10
+              sleep(0.01)
+            else
+              @spin_count = 0
+            end
+          end
+
+          remove_list.each do |i|
+            @lock.synchronize do
+              @listeners.delete_at(i)
+            end
+          end
+
+          return true
+        end
+
+        def ask_to_callback(lis)
+          BayLog.debug("%s Ask to callback: %s", self, lis)
+
+          found = false
+          for ifo in @listeners do
+            if ifo.listener == lis
+              found = true
+              break
+            end
+          end
+
+          if found
+            BayLog.error("Already registered")
+          else
+            @lock.synchronize do
+              @listeners.append(ListenerInfo.new(lis, Time.now.tv_sec))
+            end
+          end
+        end
+
+        def empty?()
+          return @listeners.empty?
+        end
+
+
+        def stop_timeout_spins()
+          if !@listeners.empty?
+            return
+          end
+
+          remove_list = []
+          @lock.synchronize do
+            now = Time.now.tv_sec
+            @listeners.length.downto(1) do |i|
+              ifo = @listeners[i-1]
+              if ifo.listener.check_timeout(int(now - ifo.last_access))
+                ifo.listener.close()
+                remove_list.append(i)
+              end
+            end
+          end
+
+          remove_list.each do |i|
+            @lock.synchronize do
+              self.listeners.pop(i)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

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

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

@@ -0,0 +1,3 @@
+require 'baykit/bayserver/agent/transporter/plain_transporter'
+require 'baykit/bayserver/agent/transporter/secure_transporter'
+require 'baykit/bayserver/agent/transporter/transporter'

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

@@ -0,0 +1,55 @@
+require 'baykit/bayserver/agent/transporter/transporter'
+require 'baykit/bayserver/protocol/protocol_exception'
+require 'baykit/bayserver/agent/next_socket_action'
+
+module Baykit
+  module BayServer
+    module Agent
+        module Transporter
+          class PlainTransporter < Baykit::BayServer::Agent::Transporter::Transporter
+            include Baykit::BayServer::Agent
+            include Baykit::BayServer::Protocol
+            include Baykit::BayServer::Util
+
+            def initialize(server_mode, bufsiz, write_only = false)
+              super(server_mode, bufsiz, false, write_only)
+            end
+
+            def init(nb_hnd, ch, lis)
+              super
+              @handshaked = true  # plain socket doesn't need to handshake
+            end
+
+            def to_s
+              return "tp[#{@data_listener}]"
+            end
+
+            ######################################################
+            # Implements Transporter
+            ######################################################
+
+            def secure()
+              return false
+            end
+
+            def handshake_nonblock
+              raise Sink.new("needless to handshake")
+            end
+
+            def read_nonblock()
+              #@ch.sysread(@capacity, @read_buf)
+              @ch.read_nonblock(@capacity, @read_buf)
+              return nil # client address (for UDP)
+            end
+
+            def write_nonblock(buf, adr)
+              #return @ch.syswrite(buf)
+              return @ch.write_nonblock(buf)
+            end
+          end
+        end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,81 @@
+require 'openssl'
+
+require 'baykit/bayserver/agent/transporter/transporter'
+require 'baykit/bayserver/agent/next_socket_action'
+
+module Baykit
+  module BayServer
+    module Agent
+        module Transporter
+          class SecureTransporter < Transporter
+            include OpenSSL
+            include Baykit::BayServer::Protocol
+
+            attr :sslctx
+            attr :ssl_socket
+
+            def initialize(sslctx, server_mode, bufsize, trace_ssl)
+              super(server_mode, bufsize, trace_ssl)
+              @sslctx = sslctx
+            end
+
+
+            def init(nb_hnd, sip, lis)
+              super
+              @ssl_socket = SSL::SSLSocket.new(@ch, @sslctx)
+              @handshaked = false
+            end
+
+            def reset()
+              super
+              @ssl_socket = nil
+            end
+
+            def to_s()
+              "stp[#{@data_listener}]"
+            end
+
+            ######################################################
+            # Implements Transporter
+            ######################################################
+
+            def secure()
+              return true
+            end
+
+            def handshake_nonblock()
+              if @server_mode
+                @ssl_socket.accept_nonblock()
+              else
+                @ssl_socket.connect_nonblock()
+              end
+
+
+              BayLog.debug("%s Handshake done", self)
+              app_protocols = @ssl_socket.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
+              @data_listener.notify_handshake_done(proto)
+            end
+
+            def read_nonblock
+              @ssl_socket.read_nonblock(@capacity, @read_buf)
+              return nil # client address (for UDP)
+            end
+
+            def write_nonblock(buf, adr)
+              @ssl_socket.write(buf)
+            end
+
+          end
+        end
+
+    end
+  end
+end