droonga-engine 1.0.4 → 1.0.5

data/lib/droonga/command/droonga_engine.rb

@@ -11,7 +11,7 @@
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "optparse"
 require "socket"
@@ -24,8 +24,7 @@ require "sigdump"
 require "droonga/path"
 require "droonga/serf"
 require "droonga/file_observer"
-require "droonga/service_control_protocol"
-require "droonga/line_buffer"
+require "droonga/process_supervisor"
 
 module Droonga
   module Command
@@ -94,14 +93,14 @@ module Droonga
       end
 
       def write_pid_file
-        if @configuration.pid_file
-          File.open(@configuration.pid_file, "w") do |file|
+        if @configuration.pid_file_path
+          @configuration.pid_file_path.open("w") do |file|
             file.puts(Process.pid)
           end
           begin
             yield
           ensure
-            FileUtils.rm_f(@configuration.pid_file)
+            FileUtils.rm_f(@configuration.pid_file_path.to_s)
           end
         else
           yield
@@ -112,14 +111,16 @@ module Droonga
         DEFAULT_HOST = Socket.gethostname
         DEFAULT_PORT = 10031
 
-        attr_reader :host, :port, :tag, :log_file, :pid_file
+        attr_reader :host, :port, :tag, :log_file, :pid_file_path
+        attr_reader :ready_notify_fd
         def initialize
           @host = DEFAULT_HOST
           @port = DEFAULT_PORT
           @tag = "droonga"
           @log_file = nil
           @daemon = false
-          @pid_file = nil
+          @pid_file_path = nil
+          @ready_notify_fd = nil
         end
 
         def engine_name
@@ -151,6 +152,7 @@ module Droonga
           add_log_options(parser)
           add_process_options(parser)
           add_path_options(parser)
+          add_notification_options(parser)
         end
 
         def listen_socket
@@ -206,9 +208,9 @@ module Droonga
                     "Run as a daemon") do
             @daemon = true
           end
-          parser.on("--pid-file=FILE",
-                    "Put PID to the FILE") do |file|
-            @pid_file = File.expand_path(file)
+          parser.on("--pid-file=PATH",
+                    "Put PID to PATH") do |path|
+            @pid_file_path = Pathname.new(path).expand_path
           end
         end
 
@@ -222,6 +224,15 @@ module Droonga
           end
         end
 
+        def add_notification_options(parser)
+          parser.separator("")
+          parser.separator("Notification:")
+          parser.on("--ready-notify-fd=FD", Integer,
+                    "Send 'ready' message to FD on ready") do |fd|
+            @ready_notify_fd = fd
+          end
+        end
+
         def bind_heartbeat_socket
           socket = UDPSocket.new(address_family)
           socket.bind(@host, @port)
@@ -239,36 +250,45 @@ module Droonga
           @serf = run_serf
           @serf_status_observer = run_serf_status_observer
           @service_runner = run_service
+          setup_initial_on_ready
           @catalog_observer = run_catalog_observer
-          @loop_breaker = Coolio::AsyncWatcher.new
-          @loop.attach(@loop_breaker)
+          @command_runner = run_command_runner
 
           trap_signals
           @loop.run
-          @serf.shutdown if @serf.running?
+          @serf.stop if @serf.running?
 
           @service_runner.success?
         end
 
         private
+        def setup_initial_on_ready
+          return if @configuration.ready_notify_fd.nil?
+          @service_runner.on_ready = lambda do
+            output = IO.new(@configuration.ready_notify_fd)
+            output.puts("ready")
+            output.close
+          end
+        end
+
         def trap_signals
           trap(:TERM) do
-            stop_gracefully
+            @command_runner.push_command(:stop_gracefully)
             trap(:TERM, "DEFAULT")
           end
           trap(:INT) do
-            stop_immediately
+            @command_runner.push_command(:stop_immediately)
             trap(:INT, "DEFAULT")
           end
           trap(:QUIT) do
-            stop_immediately
+            @command_runner.push_cmmand(:stop_immediately)
             trap(:QUIT, "DEFAULT")
           end
           trap(:USR1) do
-            restart_graceful
+            @command_runner.push_command(:restart_graceful)
           end
           trap(:HUP) do
-            restart_immediately
+            @command_runner.push_command(:restart_immediately)
           end
           trap(:USR2) do
             Sigdump.dump
@@ -276,25 +296,22 @@ module Droonga
         end
 
         def stop_gracefully
-          @loop_breaker.signal
-          @loop_breaker.detach
-          @serf.shutdown
+          @command_runner.stop
+          @serf.stop
           @serf_status_observer.stop
           @catalog_observer.stop
           @service_runner.stop_gracefully
         end
 
         def stop_immediately
-          @loop_breaker.signal
-          @loop_breaker.detach
-          @serf.shutdown
+          @command_runner.stop
+          @serf.stop
           @serf_status_observer.stop
           @catalog_observer.stop
           @service_runner.stop_immediately
         end
 
         def restart_graceful
-          @loop_breaker.signal
           old_service_runner = @service_runner
           @service_runner = run_service
           @service_runner.on_ready = lambda do
@@ -308,7 +325,6 @@ module Droonga
         end
 
         def restart_immediately
-          @loop_breaker.signal
           old_service_runner = @service_runner
           @service_runner = run_service
           old_service_runner.stop_immediately
@@ -327,7 +343,7 @@ module Droonga
         end
 
         def restart_serf
-          @serf.shutdown if @serf
+          @serf.stop if @serf
           @serf = run_serf
         end
 
@@ -348,11 +364,18 @@ module Droonga
           catalog_observer.start
           catalog_observer
         end
+
+        def run_command_runner
+          command_runner = CommandRunner.new(@loop)
+          command_runner.on_command = lambda do |command|
+            __send__(command)
+          end
+          command_runner.start
+          command_runner
+        end
       end
 
       class ServiceRunner
-        include ServiceControlProtocol
-
         def initialize(raw_loop, configuration)
           @raw_loop = raw_loop
           @configuration = configuration
@@ -394,16 +417,17 @@ module Droonga
           @pid = spawn(env, *command_line, options)
           control_write_in.close
           control_read_out.close
-          attach_control_write_out(control_write_out)
-          attach_control_read_in(control_read_in)
+          @supervisor = create_process_supervisor(control_read_in,
+                                                  control_write_out)
+          @supervisor.start
         end
 
         def stop_gracefully
-          @control_write_out.write(Messages::STOP_GRACEFUL)
+          @supervisor.stop_gracefully
         end
 
         def stop_immediately
-          @control_write_out.write(Messages::STOP_IMMEDIATELY)
+          @supervisor.stop_immediately
         end
 
         def success?
@@ -411,6 +435,17 @@ module Droonga
         end
 
         private
+        def create_process_supervisor(input, output)
+          supervisor = ProcessSupervisor.new(@raw_loop, input, output)
+          supervisor.on_ready = lambda do
+            on_ready
+          end
+          supervisor.on_finish = lambda do
+            on_finish
+          end
+          supervisor
+        end
+
         def on_ready
           @on_ready.call if @on_ready
         end
@@ -422,33 +457,46 @@ module Droonga
         def on_finish
           _, status = Process.waitpid2(@pid)
           @success = status.success?
-          @control_write_out.close
-          @control_read_in.close
+          @supervisor.stop
           on_failure unless success?
         end
+      end
 
-        def attach_control_write_out(control_write_out)
-          @control_write_out = Coolio::IO.new(control_write_out)
-          @raw_loop.attach(@control_write_out)
-        end
-
-        def attach_control_read_in(control_read_in)
-          @control_read_in = Coolio::IO.new(control_read_in)
-          line_buffer = LineBuffer.new
-          on_read = lambda do |data|
-            line_buffer.feed(data) do |line|
-              case line
-              when Messages::READY
-                on_ready
-              when Messages::FINISH
-                on_finish
-              end
+      class CommandRunner
+        attr_writer :on_command
+        def initialize(loop)
+          @loop = loop
+          @commands = []
+          @on_command = nil
+        end
+
+        def start
+          @async_watcher = Coolio::AsyncWatcher.new
+          on_signal = lambda do
+            commands = @commands.uniq
+            @commands.clear
+            until commands.empty?
+              command = commands.shift
+              @on_command.call(command) if @on_command
             end
           end
-          @control_read_in.on_read do |data|
-            on_read.call(data)
+          @async_watcher.on_signal do
+            on_signal.call
           end
-          @raw_loop.attach(@control_read_in)
+          @loop.attach(@async_watcher)
+        end
+
+        def stop
+          return if @async_watcher.nil?
+          @async_watcher.detach
+          @async_watcher = nil
+        end
+
+        def push_command(command)
+          return if @async_watcher.nil?
+          first_command_p = @commands.empty?
+          @commands << command
+          @async_watcher.signal if first_command_p
         end
       end
     end

data/lib/droonga/command/droonga_engine_service.rb

@@ -11,14 +11,13 @@
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "optparse"
 
 require "coolio"
 
-require "droonga/service_control_protocol"
-require "droonga/line_buffer"
+require "droonga/worker_process_agent"
 require "droonga/engine"
 require "droonga/fluent_message_receiver"
 require "droonga/internal_fluent_message_receiver"
@@ -34,7 +33,6 @@ module Droonga
       end
 
       include Loggable
-      include ServiceControlProtocol
 
       def initialize
         @engine_name = nil
@@ -59,10 +57,7 @@ module Droonga
           logger.exception("failed to run services", $!)
           success = false
         ensure
-          unless @control_write_closed
-            control_write_io.write(Messages::FINISH)
-            control_write_io.close
-          end
+          shutdown_worker_process_agent
         end
 
         success
@@ -118,9 +113,9 @@ module Droonga
         @loop = Coolio::Loop.default
 
         run_internal_message_receiver
+        run_worker_process_agent
         run_engine
         run_receiver
-        run_control_io
         @loop.run
       end
 
@@ -145,6 +140,9 @@ module Droonga
 
       def run_engine
         @engine = Engine.new(@loop, @engine_name, @internal_engine_name)
+        @engine.on_ready = lambda do
+          @worker_process_agent.ready
+        end
         @engine.start
       end
 
@@ -153,66 +151,23 @@ module Droonga
         @receiver.start
       end
 
-      def shutdown_receiver
-        return if @receiver.nil?
-        @receiver, receiver = nil, @receiver
-        receiver.shutdown
-      end
-
-      def run_control_io
-        @control_read = Coolio::IO.new(IO.new(@control_read_fd))
+      def run_worker_process_agent
+        input = IO.new(@control_read_fd)
         @control_read_fd = nil
-        on_read = lambda do |data|
-          line_buffer = LineBuffer.new
-          line_buffer.feed(data) do |line|
-            case line
-            when Messages::STOP_GRACEFUL
-              stop_gracefully
-            when Messages::STOP_IMMEDIATELY
-              stop_immediately
-            end
-          end
-        end
-        @control_read.on_read do |data|
-          on_read.call(data)
-        end
-        read_on_close = lambda do
-          if @control_read
-            @control_read = nil
-            stop_immediately
-          end
-        end
-        @control_read.on_close do
-          read_on_close.call
-        end
-        @loop.attach(@control_read)
-
-        @control_write = Coolio::IO.new(IO.new(@control_write_fd))
+        output = IO.new(@control_write_fd)
         @control_write_fd = nil
-        write_on_close = lambda do
-          if @control_write
-            @control_write = nil
-            stop_immediately
-          end
-          @control_write_closed = true
+        @worker_process_agent = WorkerProcessAgent.new(@loop, input, output)
+        @worker_process_agent.on_stop_gracefully = lambda do
+          stop_gracefully
         end
-        @control_write.on_close do
-          write_on_close.call
+        @worker_process_agent.on_stop_immediately = lambda do
+          stop_immediately
         end
-        @loop.attach(@control_write)
-
-        @control_write.write(Messages::READY)
+        @worker_process_agent.start
       end
 
-      def shutdown_control_io
-        if @control_write
-          @control_write, control_write = nil, @control_write
-          control_write.detach
-        end
-        if @control_read
-          @control_read, control_read = nil, @control_read
-          control_read.close
-        end
+      def shutdown_worker_process_agent
+        @worker_process_agent.stop
       end
 
       def create_receiver
@@ -250,17 +205,17 @@ module Droonga
       def stop_gracefully
         return if @stopping
         @stopping = true
-        shutdown_receiver
+        @receiver.stop_gracefully
         @engine.stop_gracefully do
-          shutdown_control_io
+          shutdown_worker_process_agent
           shutdown_internal_message_receiver
         end
       end
 
       # It may be called after stop_gracefully.
       def stop_immediately
-        shutdown_control_io
-        shutdown_receiver if @receiver
+        shutdown_worker_process_agent
+        @receiver.stop_immediately
         shutdown_internal_message_receiver
         @engine.stop_immediately
         @loop.stop

data/lib/droonga/command/droonga_engine_worker.rb

@@ -0,0 +1,232 @@
+# Copyright (C) 2013-2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "optparse"
+require "fileutils"
+
+require "coolio"
+
+require "droonga/job_receiver"
+require "droonga/plugin_loader"
+require "droonga/worker_process_agent"
+require "droonga/handler_runner"
+
+module Droonga
+  module Command
+    class DroongaEngineWorker
+      class << self
+        def run(command_line_arguments)
+          new.run(command_line_arguments)
+        end
+      end
+
+      include Loggable
+
+      def initialize
+        @job_queue_socket_path = nil
+        @contrtol_read_fd = nil
+        @contrtol_write_fd = nil
+        @pid_file_path = nil
+        @dataset = nil
+        @database_path = nil
+        @plugins = []
+        @worker_process_agent = nil
+      end
+
+      def run(command_line_arguments)
+        create_new_process_group
+
+        parse_command_line_arguments!(command_line_arguments)
+        PluginLoader.load_all
+
+        write_pid_file do
+          run_main_loop
+        end
+      end
+
+      private
+      def create_new_process_group
+        begin
+          Process.setsid
+        rescue SystemCallError, NotImplementedError
+        end
+      end
+
+      def parse_command_line_arguments!(command_line_arguments)
+        parser = OptionParser.new
+        add_internal_options(parser)
+        parser.parse!(command_line_arguments)
+      end
+
+      def add_internal_options(parser)
+        parser.separator("")
+        parser.separator("Internal:")
+        parser.on("--job-queue-socket-path=PATH",
+                  "Read jobs from PATH") do |path|
+          @job_queue_socket_path = Pathname.new(path)
+        end
+        parser.on("--control-read-fd=FD", Integer,
+                  "Use FD to read control messages from the service") do |fd|
+          @control_read_fd = fd
+        end
+        parser.on("--control-write-fd=FD", Integer,
+                  "Use FD to write control messages from the service") do |fd|
+          @control_write_fd = fd
+        end
+        parser.on("--pid-file=PATH",
+                  "Put PID to PATH") do |path|
+          @pid_file_path = Pathname.new(path)
+        end
+        parser.on("--dataset=DATASET",
+                  "Process DATASET") do |dataset|
+          @dataset = dataset
+        end
+        parser.on("--database-path=PATH",
+                  "Use database at PATH") do |path|
+          @database_path = Pathname.new(path)
+        end
+        parser.on("--plugins=PLUGIN1,PLUGIN2,...", Array,
+                  "Use PLUGINs") do |plugins|
+          @plugins = plugins
+        end
+      end
+
+      def write_pid_file
+        if @pid_file_path
+          @pid_file_path.open("w") do |file|
+            file.puts(Process.pid)
+          end
+          begin
+            yield
+          ensure
+            FileUtils.rm_f(@pid_file_path.to_s)
+          end
+        else
+          yield
+        end
+      end
+
+      def run_main_loop
+        begin
+          start
+          true
+        rescue
+          logger.exception("failed while running", $!)
+          false
+        ensure
+          stop_worker_process_agent
+        end
+      end
+
+      def start
+        @stopping = false
+        @loop = Coolio::Loop.default
+
+        start_forwarder
+        start_handler_runner
+        start_job_receiver
+        start_worker_process_agent
+
+        @loop.run
+      end
+
+      def stop_gracefully
+        return if @stopping
+        @stopping = true
+
+        stop_worker_process_agent
+        stop_job_receiver
+        stop_handler_runner
+        stop_forwarder
+      end
+
+      # It may be called after stop_gracefully.
+      def stop_immediately
+        stop_gracefully
+        @loop.stop
+      end
+
+      def start_forwarder
+        @forwarder = Forwarder.new(@loop)
+        @forwarder.start
+      end
+
+      def stop_forwarder
+        @forwarder.shutdown
+      end
+
+      def start_handler_runner
+        options = {
+          :forwarder => @forwarder,
+          :dataset   => @dataset,
+          :database  => @database_path.to_s,
+          :plugins   => @plugins,
+        }
+        @handler_runner = HandlerRunner.new(@loop, options)
+        @handler_runner.start
+      end
+
+      def stop_handler_runner
+        @handler_runner.shutdown
+      end
+
+      def start_job_receiver
+        @job_receiver = create_job_receiver
+        @job_receiver.start
+      end
+
+      def create_job_receiver
+        JobReceiver.new(@loop, @job_queue_socket_path.to_s) do |message|
+          process(message)
+        end
+      end
+
+      def process(message)
+        logger.trace("process: start")
+        @handler_runner.process(message)
+        logger.trace("process: done")
+      end
+
+      def stop_job_receiver
+        @job_receiver.shutdown
+      end
+
+      def start_worker_process_agent
+        input = IO.new(@control_read_fd)
+        @control_read_fd = nil
+        output = IO.new(@control_write_fd)
+        @control_write_fd = nil
+        @worker_process_agent = WorkerProcessAgent.new(@loop, input, output)
+        @worker_process_agent.on_stop_gracefully = lambda do
+          stop_gracefully
+        end
+        @worker_process_agent.on_stop_immediately = lambda do
+          stop_immediately
+        end
+        @worker_process_agent.start
+        @worker_process_agent.ready
+      end
+
+      def stop_worker_process_agent
+        return if @worker_process_agent.nil?
+        @worker_process_agent.stop
+      end
+
+      def log_tag
+        "[#{Process.ppid}] worker"
+      end
+    end
+  end
+end