droonga-engine 1.0.5 → 1.0.6

data/lib/droonga/command/serf_event_handler.rb

@@ -14,12 +14,9 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 require "json"
+require "fileutils"
 
-require "droonga/path"
-require "droonga/serf"
-require "droonga/catalog_generator"
-require "droonga/data_absorber"
-require "droonga/safe_file_writer"
+require "droonga/command/remote"
 
 module Droonga
   module Command
@@ -31,331 +28,67 @@ module Droonga
       end
 
       def initialize
-        @serf = ENV["SERF"] || Serf.path
-        @serf_rpc_address = ENV["SERF_RPC_ADDRESS"] || "127.0.0.1:7373"
-        @serf_name = ENV["SERF_SELF_NAME"]
-        @response = {
-          "log" => []
-        }
+        @payload = nil
       end
 
       def run
-        parse_event
-        unless event_for_me?
-          log(" => ignoring event not for me")
-          output_response
-          return true
-        end
+        command_class = detect_command_class
+        return true if command_class.nil?
 
-        process_event
-        output_live_nodes
-        output_response
+        serf_name = ENV["SERF_SELF_NAME"]
+        command = command_class.new(serf_name, @payload)
+        command.process if command.should_process?
+        output_response(command.response)
+        true
+      rescue Exception => exception
+        #XXX Any exception blocks following serf operations.
+        #    To keep it working, I rescue any exception for now.
+        FileUtils.mkdir_p(Path.serf_event_handler_errors)
+        File.open(Path.serf_event_handler_error_file, "w") do |file|
+          file.write(exception.inspect)
+        end
         true
       end
 
       private
-      def parse_event
-        @event_name = ENV["SERF_EVENT"]
-        @payload = nil
-        case @event_name
+      def detect_command_class
+        case ENV["SERF_EVENT"]
         when "user"
-          @event_sub_name = ENV["SERF_USER_EVENT"]
           @payload = JSON.parse($stdin.gets)
-          log("event sub name = #{@event_sub_name}")
+          detect_command_class_from_custom_event(ENV["SERF_USER_EVENT"])
         when "query"
-          @event_sub_name = ENV["SERF_QUERY_NAME"]
           @payload = JSON.parse($stdin.gets)
-          log("event sub name = #{@event_sub_name}")
+          detect_command_class_from_custom_event(ENV["SERF_QUERY_NAME"])
         when "member-join", "member-leave", "member-update", "member-reap"
-          output_live_nodes
+          Remote::UpdateLiveNodes
+        else
+          nil
         end
       end
 
-      def event_for_me?
-        return true unless @payload
-        return true unless @payload["node"]
-
-        @payload["node"] == @serf_name
-      end
-
-      def process_event
-        case @event_sub_name
+      def detect_command_class_from_custom_event(event_name)
+        case event_name
         when "change_role"
-          save_status(:role, @payload["role"])
+          Remote::ChangeRole
         when "report_status"
-          report_status
+          Remote::ReportStatus
         when "join"
-          join
+          Remote::Join
         when "set_replicas"
-          set_replicas
+          Remote::SetReplicas
         when "add_replicas"
-          add_replicas
+          Remote::AddReplicas
         when "remove_replicas"
-          remove_replicas
+          Remote::RemoveReplicas
         when "absorb_data"
-          absorb_data
-        when "publish_catalog"
-          publish_catalog
-        when "unpublish_catalog"
-          unpublish_catalog
-        end
-      end
-
-      def output_response
-        puts JSON.generate(@response)
-      end
-
-      def host
-        @serf_name.split(":").first
-      end
-
-      def given_hosts
-        hosts = @payload["hosts"]
-        return nil unless hosts
-        hosts = [hosts] if hosts.is_a?(String)
-        hosts
-      end
-
-      def report_status
-        @response["value"] = status(@payload["key"].to_sym)
-      end
-
-      def join
-        type = @payload["type"]
-        log("type = #{type}")
-        case type
-        when "replica"
-          join_as_replica
+          Remote::AbsorbData
+        else
+          nil
         end
       end
 
-      def join_as_replica
-        source_node = @payload["source"]
-        return unless source_node
-
-        log("source_node  = #{source_node}")
-
-        source_host = source_node.split(":").first
-
-        # fetch_port = @payload["fetch_port"]
-        # catalog = fetch_catalog(source_node, fetch_port)
-        catalog = JSON.parse(Path.catalog.read) #XXX workaround until "fetch" become available
-
-        generator = create_current_catalog_generator(catalog)
-        dataset = generator.dataset_for_host(source_host) ||
-                    generator.dataset_for_host(host)
-        return unless dataset
-
-        # restart self with the fetched catalog.
-        SafeFileWriter.write(Path.catalog, JSON.pretty_generate(catalog))
-
-        dataset_name = dataset.name
-        tag          = dataset.replicas.tag
-        port         = dataset.replicas.port
-        other_hosts  = dataset.replicas.hosts
-
-        log("dataset = #{dataset_name}")
-        log("port    = #{port}")
-        log("tag     = #{tag}")
-
-        if @payload["copy"]
-          log("starting to copy data from #{source_host}")
-
-          modify_catalog do |modifier|
-            modifier.datasets[dataset_name].replicas.hosts = [host]
-          end
-          sleep(5) #TODO: wait for restart. this should be done more safely, to avoid starting of absorbing with old catalog.json.
-
-          save_status(:absorbing, true)
-          DataAbsorber.absorb(:dataset          => dataset_name,
-                              :source_host      => source_host,
-                              :destination_host => host,
-                              :port             => port,
-                              :tag              => tag)
-          delete_status(:absorbing)
-          sleep(1)
-        end
-
-        log("joining to the cluster: update myself")
-
-        modify_catalog do |modifier|
-          modifier.datasets[dataset_name].replicas.hosts += other_hosts
-          modifier.datasets[dataset_name].replicas.hosts.uniq!
-        end
-      end
-
-      def fetch_catalog(source_node, port)
-        source_host = source_node.split(":").first
-
-        url = "http://#{source_host}:#{port}"
-        connection = Faraday.new(url) do |builder|
-          builder.response(:follow_redirects)
-          builder.adapter(Faraday.default_adapter)
-        end
-        response = connection.get("/catalog.json")
-        catalog = response.body
-
-        JSON.parse(catalog)
-      end
-
-      def publish_catalog
-        port = @payload["port"]
-        return unless port
-
-        env = {}
-        publisher_command_line = [
-          "droonga-engine-data-publisher",
-            "--base-dir", Path.base.to_s,
-            "--port", port.to_s,
-            "--published-file", Path.catalog.to_s
-        ]
-        pid = spawn(env, *publisher_command_line)
-        Process.detach(pid)
-        sleep(1) # wait until the directory is published
-
-        published_dir = Path.published(port)
-        pid_file = published_dir + ".pid"
-
-        File.open(pid_file.to_s, "w") do |file|
-          file.puts(pid)
-        end
-      end
-
-      def unpublish_catalog
-        port = @payload["port"]
-        return unless port
-
-        published_dir = Path.published(port)
-        pid_file = published_dir + ".pid"
-        pid = pid_file.read.to_i
-
-        Process.kill("INT", pid)
-      end
-
-      def set_replicas
-        dataset = @payload["dataset"]
-        return unless dataset
-
-        hosts = given_hosts
-        return unless hosts
-
-        log("new replicas: #{hosts.join(",")}")
-
-        modify_catalog do |modifier|
-          modifier.datasets[dataset].replicas.hosts = hosts
-        end
-      end
-
-      def add_replicas
-        dataset = @payload["dataset"]
-        return unless dataset
-
-        hosts = given_hosts
-        return unless hosts
-
-        hosts -= [host]
-        return if hosts.empty?
-
-        log("adding replicas: #{hosts.join(",")}")
-
-        modify_catalog do |modifier|
-          modifier.datasets[dataset].replicas.hosts += hosts
-          modifier.datasets[dataset].replicas.hosts.uniq!
-        end
-      end
-
-      def remove_replicas
-        dataset = @payload["dataset"]
-        return unless dataset
-
-        hosts = given_hosts
-        return unless hosts
-
-        log("removing replicas: #{hosts.join(",")}")
-
-        modify_catalog do |modifier|
-          modifier.datasets[dataset].replicas.hosts -= hosts
-        end
-      end
-
-      def modify_catalog
-        generator = create_current_catalog_generator
-        yield(generator)
-        SafeFileWriter.write(Path.catalog, JSON.pretty_generate(generator.generate))
-      end
-
-      def create_current_catalog_generator(current_catalog=nil)
-        current_catalog ||= JSON.parse(Path.catalog.read)
-        generator = CatalogGenerator.new
-        generator.load(current_catalog)
-      end
-
-      def absorb_data
-        source = @payload["source"]
-        return unless source
-
-        log("start to absorb data from #{source}")
-
-        dataset_name = @payload["dataset"]
-        port         = @payload["port"]
-        tag          = @payload["tag"]
-
-        if dataset_name.nil? or port.nil? or tag.nil?
-          current_catalog = JSON.parse(Path.catalog.read)
-          generator = CatalogGenerator.new
-          generator.load(current_catalog)
-
-          dataset = generator.dataset_for_host(source)
-          return unless dataset
-
-          dataset_name = dataset.name
-          port = dataset.replicas.port
-          tag  = dataset.replicas.tag
-        end
-
-        log("dataset = #{dataset_name}")
-        log("port    = #{port}")
-        log("tag     = #{tag}")
-
-        save_status(:absorbing, true)
-        DataAbsorber.absorb(:dataset          => dataset_name,
-                            :source_host      => source,
-                            :destination_host => host,
-                            :port             => port,
-                            :tag              => tag,
-                            :client           => "droonga-send")
-        delete_status(:absorbing)
-      end
-
-      def live_nodes
-        Serf.live_nodes(@serf_name)
-      end
-
-      def output_live_nodes
-        path = Path.live_nodes
-        nodes = live_nodes
-        file_contents = JSON.pretty_generate(nodes)
-        SafeFileWriter.write(path, file_contents)
-      end
-
-      def status(key)
-        Serf.status(key)
-      end
-
-      def save_status(key, value)
-        status = Serf.load_status
-        status[key] = value
-        SafeFileWriter.write(Serf.status_file, JSON.pretty_generate(status))
-      end
-
-      def delete_status(key)
-        status = Serf.load_status
-        status.delete(key)
-        SafeFileWriter.write(Serf.status_file, JSON.pretty_generate(status))
-      end
-
-      def log(message)
-        @response["log"] << message
+      def output_response(response)
+        puts JSON.generate(response)
       end
     end
   end

data/lib/droonga/dispatcher.rb

@@ -69,7 +69,20 @@ module Droonga
       @farm.start
     end
 
-    def shutdown
+    def stop_gracefully(&on_stop)
+      logger.trace("stop_gracefully: start")
+      @collector_runners.each_value do |collector_runner|
+        collector_runner.shutdown
+      end
+      @adapter_runners.each_value do |adapter_runner|
+        adapter_runner.shutdown
+      end
+      @farm.stop_gracefully(&on_stop)
+      logger.trace("stop_gracefully: done")
+    end
+
+    def stop_immediately
+      logger.trace("stop_immediately: start")
       @collector_runners.each_value do |collector_runner|
         collector_runner.shutdown
       end
@@ -77,6 +90,7 @@ module Droonga
         adapter_runner.shutdown
       end
       @farm.shutdown
+      logger.trace("stop_immediately: done")
     end
 
     def process_message(message)

data/lib/droonga/engine/version.rb

@@ -15,6 +15,6 @@
 
 module Droonga
   class Engine
-    VERSION = "1.0.5"
+    VERSION = "1.0.6"
   end
 end

data/lib/droonga/engine.rb

@@ -57,14 +57,19 @@ module Droonga
       logger.trace("stop_gracefully: start")
       @live_nodes_list_observer.stop
       on_finish = lambda do
+        logger.trace("stop_gracefully/on_finish: start")
         output_last_processed_timestamp
-        @dispatcher.shutdown
-        @state.shutdown
-        yield
+        @dispatcher.stop_gracefully do
+          @state.shutdown
+          yield
+        end
+        logger.trace("stop_gracefully/on_finish: done")
       end
       if @state.have_session?
+        logger.trace("stop_gracefully/having sessions")
         @state.on_finish = on_finish
       else
+        logger.trace("stop_gracefully/no session")
         on_finish.call
       end
       logger.trace("stop_gracefully: done")
@@ -75,7 +80,7 @@ module Droonga
       logger.trace("stop_immediately: start")
       output_last_processed_timestamp
       @live_nodes_list_observer.stop
-      @dispatcher.shutdown
+      @dispatcher.stop_immediately
       @state.shutdown
       logger.trace("stop_immediately: done")
     end
@@ -112,11 +117,13 @@ module Droonga
     end
 
     def output_last_processed_timestamp
+      logger.trace("output_last_processed_timestamp: start")
       path = Path.last_processed_timestamp
       FileUtils.mkdir_p(path.dirname.to_s)
       path.open("w") do |file|
         file.write(@last_processed_timestamp)
       end
+      logger.trace("output_last_processed_timestamp: done")
     end
 
     def effective_message?(message)

data/lib/droonga/engine_state.rb

@@ -90,6 +90,7 @@ module Droonga
 
     def register_session(id, session)
       @sessions[id] = session
+      logger.trace("new session #{id} is registered. rest sessions=#{@sessions.size}")
     end
 
     def unregister_session(id)
@@ -97,6 +98,7 @@ module Droonga
       unless have_session?
         @on_finish.call if @on_finish
       end
+      logger.trace("session #{id} is unregistered. rest sessions=#{@sessions.size}")
     end
 
     def have_session?

data/lib/droonga/farm.rb

@@ -49,14 +49,23 @@ module Droonga
       end
     end
 
-    def shutdown
-      threads = []
+    def stop_gracefully
+      n_slices = @slices.size
+      n_done_slices = 0
       @slices.each_value do |slice|
-        threads << Thread.new do
-          slice.shutdown
+        slice.stop_gracefully do
+          n_done_slices += 1
+          if n_done_slices == n_slices
+            yield if block_given?
+          end
         end
       end
-      threads.each(&:join)
+    end
+
+    def stop_immediately
+      @slices.each_value do |slice|
+        slice.stop_immediately
+      end
     end
 
     def process(slice_name, message)

data/lib/droonga/fluent_message_receiver.rb

@@ -43,6 +43,7 @@ module Droonga
     def stop_gracefully
       logger.trace("stop_gracefully: start")
       shutdown_heartbeat_receiver
+      logger.trace("stop_gracefully: middle")
       shutdown_server
       logger.trace("stop_gracefully: done")
     end
@@ -54,6 +55,12 @@ module Droonga
       logger.trace("stop_immediately: done")
     end
 
+    def shutdown_clients
+      @clients.dup.each do |client|
+        client.close
+      end
+    end
+
     private
     def start_heartbeat_receiver
       logger.trace("start_heartbeat_receiver: start")
@@ -76,6 +83,9 @@ module Droonga
         client = Client.new(connection) do |tag, time, record|
           @on_message.call(tag, time, record)
         end
+        client.on_close = lambda do
+          @clients.delete(client)
+        end
         @clients << client
       end
       @loop.attach(@server)
@@ -88,13 +98,9 @@ module Droonga
     end
 
     def shutdown_server
+      logger.trace("shutdown_server: start")
       @server.close
-    end
-
-    def shutdown_clients
-      @clients.each do |client|
-        client.close
-      end
+      logger.trace("shutdown_server: done")
     end
 
     def log_tag
@@ -152,16 +158,27 @@ module Droonga
     class Client
       include Loggable
 
+      attr_accessor :on_close
       def initialize(io, &on_message)
         @io = io
         @on_message = on_message
+        @on_close = nil
         @unpacker = MessagePack::Unpacker.new
+
         on_read = lambda do |data|
           feed(data)
         end
         @io.on_read do |data|
           on_read.call(data)
         end
+
+        on_close = lambda do
+          @io = nil
+          @on_close.call if @on_close
+        end
+        @io.on_close do
+          on_close.call
+        end
       end
 
       def close

data/lib/droonga/fluent_message_sender.rb

@@ -34,6 +34,7 @@ module Droonga
       @host = host
       @port = port
       @socket = nil
+      @packer = MessagePackPacker.new
       @buffering = options[:buffering]
     end
 
@@ -114,7 +115,10 @@ module Droonga
 
     def create_packed_fluent_message(tag, data)
       fluent_message = [tag, Time.now.to_i, data]
-      MessagePackPacker.pack(fluent_message)
+      @packer.pack(fluent_message)
+      packed_fluent_message = @packer.to_s
+      @packer.clear
+      packed_fluent_message
     end
 
     def log_tag

data/lib/droonga/node_status.rb

@@ -0,0 +1,67 @@
+# Copyright (C) 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 "json"
+require "droonga/path"
+require "droonga/safe_file_writer"
+
+module Droonga
+  class NodeStatus
+    def initialize
+      @status = load
+    end
+
+    def have?(key)
+      key = normalize_key(key)
+      @status.include?(key)
+    end
+
+    def get(key)
+      key = normalize_key(key)
+      @status[key]
+    end
+
+    def set(key, value)
+      key = normalize_key(key)
+      @status[key] = value
+      SafeFileWriter.write(status_file, JSON.pretty_generate(@status))
+    end
+
+    def delete(key)
+      key = normalize_key(key)
+      @status.delete(key)
+      SafeFileWriter.write(status_file, JSON.pretty_generate(@status))
+    end
+
+    private
+    def normalize_key(key)
+      key.to_sym
+    end
+
+    def status_file
+      @status_file ||= Path.state + "status_file"
+    end
+
+    def load
+      if status_file.exist?
+        contents = status_file.read
+        unless contents.empty?
+          return JSON.parse(contents, :symbolize_names => true)
+        end
+      end
+      {}
+    end
+  end
+end