serverengine 1.6.4 → 2.0.0pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1905531d61188949bea25a5bd1aa56882b9fd0e
-  data.tar.gz: 225c5c5204167c726710c4790def2f5b7794e179
+  metadata.gz: 9c2c41ca45cff7f607a22a6861bd7b55e03a70b7
+  data.tar.gz: 97948ab60c218ef17becfb05723270592cc7540c
 SHA512:
-  metadata.gz: c2a704566a28f1e90f44934d97e976e82aee1d6867b77bc6497b015c38fef2f538583bb614bdef18de91061b9e1927aa864c7eb50e5e1b0448f8b73eeb4293b6
-  data.tar.gz: c5bab7f53971af7eeaeb4a0a7a58bab5c921d6d39d2c0e00ea154c6cedce39ebe23bf675f8f31896d0dc5fed3b36b218d1e8e079402c97e1d86894dd0448b2a1
+  metadata.gz: 38ff87ed7b173030bb5293c0d3e89a824efae90b9e87c5a6fefa22f61c3e14b737c4e28cc92e783fc51568f517a5aea5393b69a46de7c8aa26892f24ec0190d9
+  data.tar.gz: 143bfeb1386750fc4275e68d9555551e450ffa57e9c9a408a6fb2e313b421301e4bef62d320ad3a8f0906936bc43f453a92d895ec1103a2735478f1561b3d76a

data/.gitignore

@@ -1,3 +1,5 @@
 Gemfile.lock
 tmp/*
 pkg/*
+myserver.log
+myserver.pid

data/Changelog

@@ -1,3 +1,14 @@
+2016-08-23 version 2.0.0:
+
+* Add windows-pr gem dependency to get ruby_bin_path correctly
+* Add command sender feature to use pipe to control workers for Windows
+* Delete MultiprocessLogDevice implementation to use Ruby's one always. This
+  means removal of backward workaround code for Ruby < 2.1.
+* Refactor modules and methods to clean internal file dependency Internal
+  symbol `ServerEngine::Daemon::Signals` is moved to `ServerEngine::Signals`
+* Add example script to run servers
+* Fix required Ruby version to 2.1 or later
+
 2016-05-19 version 1.6.4:
 
 * Refactor to delete some warnings

data/README.md

@@ -68,7 +68,7 @@ se = ServerEngine.create(nil, MyWorker, {
 se.run
 ```
 
-Send `TERM` signal to kill the daemon. See also **Signals** section bellow for details.
+Send `TERM` signal (or `KILL` on Windows) to kill the daemon. See also **Signals** section bellow for details.
 
 
 ### Multiprocess server
@@ -141,6 +141,12 @@ ServerEngine provides **worker_type: "spawn"** for those platforms (This is stil
 
 What you need to implement at least to use worker_type: "spawn" is `def spawn(process_manager)` method. You will call `process_manager.spawn` at the method, where `spawn` is same with `Process.spawn` excepting return value.
 
+In addition, Windows does not support signals.  ServerEngine provides **command_sender: "pipe"** for Windows (and for other platforms, if you want to use it).
+When using **command_sender: "pipe"**, the child process have to handle commands sent from parent process via STDIN.
+On Windows, **command_sender: "pipe"** is default.
+
+You can call `Server#stop(stop_graceful)` and `Server#restart(stop_graceful)` instead of sending signals.
+
 ```ruby
 module MyWorker
   def spawn(process_manager)
@@ -155,8 +161,20 @@ module MyWorker
       logger = ServerEngine::DaemonLogger.new(conf[:log] || STDOUT, conf)
 
       @stop = false
-      trap(:SIGTERM) { @stop = true }
-      trap(:SIGINT) { @stop = true }
+      command_pipe = STDIN.dup
+      STDIN.reopen(File::NULL)
+      Thread.new do
+        until @stop
+          case command_pipe.gets.chomp
+          when "GRACEFUL_STOP"
+            @stop = true
+          when "IMMEDIATE_STOP"
+            @stop = true
+          when "GRACEFUL_RESTART", "IMMEDIATE_RESTART"
+            # do something...
+          end
+        end
+      end
 
       until @stop
         logger.info 'Awesome work!'
@@ -169,6 +187,7 @@ end
 
 se = ServerEngine.create(nil, MyWorker, {
   worker_type: 'spawn',
+  command_sender: 'pipe',
   log: 'myserver.log',
 })
 se.run
@@ -213,6 +232,7 @@ se = ServerEngine.create(nil, MyWorker, {
 se.run
 ```
 
+This auto restart reature will be suppressed for workers which exits with exit code specified by `unrecoverable_exit_codes`. At this case, whole process will exit without error (exit code 0).
 
 ## Live restart
 
@@ -304,6 +324,10 @@ Send `USR2` signal to reload configuration file.
 Immediate shutdown and restart send SIGQUIT signal to worker processes which kills the processes.
 Graceful shutdown and restart call `Worker#stop` method and wait for completion of `Worker#run` method.
 
+Note that signals are not supported on Windows.
+You have to use piped command instead of signals on Windows.
+See also **Multiprocess server on Windows and JRuby platforms** section.
+
 
 ## Utilities
 
@@ -388,6 +412,8 @@ se = ServerEngine.create(MyServer, MyWorker, {
 se.run
 ```
 
+See also [examples](https://github.com/fluent/serverengine/tree/master/examples).
+
 
 ## Module API
 
@@ -464,6 +490,8 @@ Available methods are different depending on `worker_type`. ServerEngine support
   - **worker_immediate_kill_interval** sets the first interval of QUIT signals in seconds (default: 10) [dynamic reloadable]
   - **worker_immediate_kill_interval_increment** sets increment of QUIT signal interval in seconds (default: 10) [dynamic reloadable]
   - **worker_immediate_kill_timeout** sets promotion timeout from QUIT to KILL signal in seconds. -1 means no timeout (default: 600) [dynamic reloadable]
+  - **unrecoverable_exit_codes** handles worker processes, which exits with code included in this value, as unrecoverable (not to restart) (default: [])
+  - **stop_immediately_at_unrecoverable_exit** stops server immediately if a worker exits with unrecoverable exit status (default: false)
 - Multiprocess spawn server: available only when `worker_type` is "spawn"
   - all parameters of multiprocess server excepting worker_process_name
   - **worker_reload_signal** sets the signal to notice configuration reload to a spawned process. Set nil to disable (default: nil)

data/Rakefile

@@ -6,8 +6,21 @@ require 'rake/clean'
 
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.fail_on_error = false
+RSpec::Core::RakeTask.new(:spec)
+task :default => [:spec, :build]
+
+# 1. update Changelog and lib/serverengine/version.rb
+# 2. bundle && bundle exec rake build:all
+# 3. release 3 packages built on pkg/ directory
+namespace :build do
+  desc 'Build gems for all platforms'
+  task :all do
+    Bundler.with_clean_env do
+      %w[ruby x86-mingw32 x64-mingw32].each do |name|
+        ENV['GEM_BUILD_FAKE_PLATFORM'] = name
+        Rake::Task["build"].execute
+      end
+    end
+  end
 end
 
-task :default => [:spec, :build]

data/appveyor.yml

@@ -10,9 +10,15 @@ test_script:
 
 environment:
   matrix:
-    - ruby_version: "200"
-    - ruby_version: "200-x64"
-    - ruby_version: "21"
-    - ruby_version: "21-x64"
+    - ruby_version: "23-x64"
+      devkit: C:\Ruby23-x64\DevKit
+    - ruby_version: "23"
+      devkit: C:\Ruby23\DevKit
+    - ruby_version: "22-x64"
+      devkit: C:\Ruby23-x64\DevKit
     - ruby_version: "22"
-    - ruby_version: "22-x64"
+      devkit: C:\Ruby23\DevKit
+    - ruby_version: "21-x64"
+      devkit: C:\Ruby23-x64\DevKit
+    - ruby_version: "21"
+      devkit: C:\Ruby23\DevKit

data/examples/server.rb

@@ -0,0 +1,138 @@
+require 'serverengine'
+
+require 'json'
+require 'optparse'
+
+# This is a script to run ServerEngine and SocketManager as a real process.
+# bundle exec ruby example/server.rb [-t TYPE] [-w NUM]
+# available type of workers are: embedded(default), process, thread, spawn
+
+foreground = false
+supervisor = false
+worker_type = nil
+workers = 4
+exit_with_code = nil
+exit_at_seconds = 5
+exit_at_random = false
+stop_immediately_at_exit = false
+unrecoverable_exit_codes = []
+
+opt = OptionParser.new
+opt.on('-f'){ foreground = true }
+opt.on('-x'){ supervisor = true }
+opt.on('-t TYPE'){|v| worker_type = v }
+opt.on('-w NUM'){|v| workers = v.to_i }
+opt.on('-e NUM'){|v| exit_with_code = v.to_i }
+opt.on('-s NUM'){|v| exit_at_seconds = v.to_i }
+opt.on('-r'){ exit_at_random = true }
+opt.on('-i'){ stop_immediately_at_exit = true }
+opt.on('-u NUM'){|v| unrecoverable_exit_codes << v.to_i }
+opt.parse!(ARGV)
+
+if exit_with_code
+  ENV['EXIT_WITH_CODE'] = exit_with_code.to_s
+  ENV['EXIT_AT_SECONDS'] = exit_at_seconds.to_s
+  if exit_at_random
+    ENV['EXIT_AT_RANDOM'] = 'true'
+  end
+end
+
+module MyServer
+  attr_reader :socket_manager_path
+
+  def before_run
+    @socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+    @socket_manager_server = ServerEngine::SocketManager::Server.open(@socket_manager_path)
+  rescue Exception => e
+    logger.error "unexpected error in server, class #{e.class}: #{e.message}"
+    raise
+  end
+
+  def after_run
+    logger.info "Server stopped."
+    @socket_manager_server.close
+  end
+end
+
+module MyWorker
+  def initialize
+    @stop = false
+    @socket_manager = ServerEngine::SocketManager::Client.new(server.socket_manager_path)
+    @exit_with_code = ENV.key?('EXIT_WITH_CODE') ? ENV['EXIT_WITH_CODE'].to_i : nil
+    @exit_at_seconds = ENV.key?('EXIT_AT_SECONDS') ? ENV['EXIT_AT_SECONDS'].to_i : nil
+    @exit_at_random = ENV.key?('EXIT_AT_RANDOM')
+  end
+
+  def main
+    # test to listen the same port
+    logger.info "Starting to run Worker."
+    _listen_sock = @socket_manager.listen_tcp('0.0.0.0', 12345)
+    stop_at = if @exit_with_code
+                stop_seconds = @exit_at_random ? rand(@exit_at_seconds) : @exit_at_seconds
+                logger.info "Stop #{stop_seconds} seconds later with code #{@exit_with_code}."
+                Time.now + stop_seconds
+              else
+                nil
+              end
+    until @stop
+      if stop_at && Time.now >= stop_at
+        logger.info "Exitting with code #{@exit_with_code}"
+        exit! @exit_with_code
+      end
+      logger.info "Awesome work!"
+      sleep 1
+    end
+    logger.info "Exitting"
+  rescue Exception => e
+    logger.warn "unexpected error, class #{e.class}: #{e.message}"
+    raise
+  end
+
+  def stop
+    @stop = true
+  end
+end
+
+module MySpawnWorker
+  def spawn(process_manager)
+    env = {
+      'SERVER_ENGINE_CONFIG' => config.to_json,
+      'SERVER_ENGINE_SOCKET_MANAGER_PATH' => server.socket_manager_path,
+    }
+    if ENV['EXIT_WITH_CODE']
+      env['EXIT_WITH_CODE'] = ENV['EXIT_WITH_CODE']
+      env['EXIT_AT_SECONDS'] = ENV['EXIT_AT_SECONDS']
+      if ENV['EXIT_AT_RANDOM']
+        env['EXIT_AT_RANDOM'] = 'true'
+      end
+    end
+    process_manager.spawn(env, "ruby", File.expand_path("../spawn_worker_script.rb", __FILE__))
+  rescue Exception => e
+    logger.error "unexpected error, class #{e.class}: #{e.message}"
+    raise
+  end
+end
+
+opts = {
+  daemonize: !foreground,
+  daemon_process_name: 'mydaemon',
+  supervisor: supervisor,
+  log: 'myserver.log',
+  pid_path: 'myserver.pid',
+  worker_type: worker_type,
+  workers: workers,
+}
+if stop_immediately_at_exit
+  opts[:stop_immediately_at_unrecoverable_exit] = true
+end
+unless unrecoverable_exit_codes.empty?
+  opts[:unrecoverable_exit_codes] = unrecoverable_exit_codes
+end
+
+worker_klass = MyWorker
+if worker_type == 'spawn'
+  worker_klass = MySpawnWorker
+end
+se = ServerEngine.create(MyServer, worker_klass, opts)
+
+se.run

data/examples/spawn_worker_script.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift File.expand_path("../..", __FILE__)
+
+require 'serverengine'
+require 'json'
+
+begin
+  conf = JSON.parse(ENV['SERVER_ENGINE_CONFIG'], symbolize_names: true)
+  logger = ServerEngine::DaemonLogger.new(conf[:log] || STDOUT, conf)
+  logger.info "Starting to run Worker."
+  socket_manager = ServerEngine::SocketManager::Client.new(ENV['SERVER_ENGINE_SOCKET_MANAGER_PATH'])
+  exit_with_code = ENV.key?('EXIT_WITH_CODE') ? ENV['EXIT_WITH_CODE'].to_i : nil
+  exit_at_seconds = ENV.key?('EXIT_AT_SECONDS') ? ENV['EXIT_AT_SECONDS'].to_i : nil
+  exit_at_random = ENV.key?('EXIT_AT_RANDOM')
+  stop_at = if exit_with_code
+              stop_seconds = exit_at_random ? rand(exit_at_seconds) : exit_at_seconds
+              logger.info "Stop #{stop_seconds} seconds later with code #{exit_with_code}."
+              Time.now + stop_seconds
+            else
+              nil
+            end
+
+  @stop = false
+  trap(:SIGTERM) { @stop = true }
+  trap(:SIGINT) { @stop = true }
+
+  _listen_sock = socket_manager.listen_tcp('0.0.0.0', 12345)
+  until @stop
+    if stop_at && Time.now >= stop_at
+      logger.info "Exitting with code #{exit_with_code}"
+      exit! exit_with_code
+    end
+    logger.info 'Awesome work!'
+    sleep 1
+  end
+  logger.info 'Exitting'
+rescue Exception => e
+  logger.error "unexpected error in spawn worker, class #{e.class}: #{e.message}"
+end

data/lib/serverengine/blocking_flag.rb

@@ -15,10 +15,9 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-module ServerEngine
-
-  require 'thread'
+require 'thread'
 
+module ServerEngine
   class BlockingFlag
     def initialize
       @set = false

data/lib/serverengine/command_sender.rb

@@ -0,0 +1,89 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require 'serverengine/signals'
+
+module ServerEngine
+  module CommandSender
+    # requires send_signal method or @pid
+    module Signal
+      private
+      def _stop(graceful)
+        _send_signal(!ServerEngine.windows? && graceful ? Signals::GRACEFUL_STOP : Signals::IMMEDIATE_STOP)
+      end
+
+      def _restart(graceful)
+        _send_signal(graceful ? Signals::GRACEFUL_RESTART : Signals::IMMEDIATE_RESTART)
+      end
+
+      def _reload
+        _send_signal(Signals::RELOAD)
+      end
+
+      def _detach
+        _send_signal(Signals::DETACH)
+      end
+
+      def _dump
+        _send_signal(Signals::DUMP)
+      end
+
+      def _send_signal(sig)
+        if respond_to?(:send_signal, true)
+          send_signal(sig)
+        else
+          Process.kill(sig, @pid)
+        end
+      end
+    end
+
+    # requires @command_sender_pipe
+    module Pipe
+      private
+      def _stop(graceful)
+        begin
+          _send_command(graceful ? "GRACEFUL_STOP" : "IMMEDIATE_STOP")
+        rescue Errno::EPIPE
+          # already stopped, then nothing to do
+        ensure
+          @command_sender_pipe.close rescue nil
+          @command_sender_pipe = nil
+        end
+      end
+
+      def _restart(graceful)
+        _send_command(graceful ? "GRACEFUL_RESTART" : "IMMEDIATE_RESTART")
+      end
+
+      def _reload
+        _send_command("RELOAD")
+      end
+
+      def _detach
+        _send_command("DETACH")
+      end
+
+      def _dump
+        _send_command("DUMP")
+      end
+
+      def _send_command(cmd)
+        @command_sender_pipe.write cmd + "\n"
+      end
+    end
+  end
+end

data/lib/serverengine/config_loader.rb

@@ -15,6 +15,8 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require 'serverengine/daemon_logger'
+
 module ServerEngine
 
   module ConfigLoader