serverengine 1.5.9 → 1.5.10

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTE3MmE3Y2NkZWFlY2VmNmFmYjc4ZTk1MWEzYTIyMDQwYjNkZDY0Ng==
+    OWNiN2U5ZGRhMjk1NGI1ZDAxNmY3OWE5OTZkMWI0ZDI5Nzg3NDQzYw==
   data.tar.gz: !binary |-
-    NGExMjkzMDk3MjdjZjA5ZDBmM2U0OGM0YWViZjgxZWRlNTVmMjg4Mg==
+    MTFlMzk4MjE1ZDdhZDdiMWRkNzg2YmY3M2MxMWU5MjY5OWU3ZTFkNw==
 SHA512:
   metadata.gz: !binary |-
-    MGY1NzhmY2Q2MDUzNzljNTVlYjcwNDQ3ZjBiYzQ3NWY4ZDA0MTQzYzViMTZi
-    YTVmNzhlNzIzM2RhOWVkNDZkMzFkNmRhODc0ZTBmMzM1MThkM2VhNTg2NjY0
-    YTZlMmFmNGJlMWMxMzBjNTRiNmU4MjQyZDdkY2U2NWUwZjdiNmM=
+    NGI0NjQyMWMxNTJmMzBlYTFhM2YwM2U2OGUwMWM4OGMzMzI4ODA4YmQ4ZGI3
+    ZjE5MTUzMzk2YTJkYWVjNTNkMzU0ZjkwZWU1ODY2M2VkNDUwZmM5ZjgxY2Qw
+    NWUyYzhmOWIyYTA0ZGQ3ZGUwYWMwYTNjODZlNzAyM2IwNWFlNDI=
   data.tar.gz: !binary |-
-    OWJjOTljMWI5MTcxNzkwYzJjYmQxNWI3MTYwMTUzMTMxYzhhNjRlYzNlNjZl
-    NDYzYjJiZWJkNTQ3NTM2NzYzZmM5ZjRhNzRjMTVmMDNiMjJjNzkyNTE5MjIx
-    YmUwMjkwMDQ1ZTc0ZTQxMTY0NDBkYzY5NzE0MDc2ZDNmYWQ0NTk=
+    ZTRjMWQ0N2E4OTI5ZGUzOTZjYTU3ZTI5MzVmYzdiMjBjOGU5Yjg4NzBjOGE0
+    OGEwYzM2MDNiMTc5ZmE1NDQ4MjkwNGVhZjFiZDIxMzEzMTBiNzRkOWU0ZTM0
+    NmFkZWM1NTgyYjBmOGRhYzU1NmZjNzJiOGM5ZDYyNjBiYzQxNDI=

data/Changelog

@@ -1,4 +1,13 @@
 
+2014-10-27 version 1.5.10:
+
+* Added worker_type=spawn (experimental)
+* Fixed Worker#config to reference Server#config so that Worker#reload reads
+  the new config reloaded by Server#reload (=ConfigLoader#reload_config) in
+  worker_type=thread and embedded
+* Server#stop, #restart and #reload show a debug log message
+
+
 2014-07-24 version 1.5.9:
 
 * Fixed DaemonLogger#reoepen! on Ruby >= 2.1.0

data/README.md

@@ -50,9 +50,9 @@ module MyWorker
 end
 
 se = ServerEngine.create(nil, MyWorker, {
-  :daemonize => true,
-  :log => 'myserver.log',
-  :pid_path => 'myserver.pid',
+  daemonize: true,
+  log: 'myserver.log',
+  pid_path: 'myserver.pid',
 })
 se.run
 ```
@@ -66,11 +66,11 @@ Simply set **worker_type=process** or **worker_type=thread** parameter, and set
 
 ```ruby
 se = ServerEngine.create(nil, MyWorker, {
-  :daemonize => true,
-  :log => 'myserver.log',
-  :pid_path => 'myserver.pid',
-  :worker_type => 'process',
-  :workers => 4,
+  daemonize: true,
+  log: 'myserver.log',
+  pid_path: 'myserver.pid',
+  worker_type: 'process',
+  workers: 4,
 })
 se.run
 ```
@@ -111,13 +111,54 @@ module MyWorker
 end
 
 se = ServerEngine.create(MyServer, MyWorker, {
-  :daemonize => true,
-  :log => 'myserver.log',
-  :pid_path => 'myserver.pid',
-  :worker_type => 'process',
-  :workers => 4,
-  :bind => '0.0.0.0',
-  :port => 9071,
+  daemonize: true,
+  log: 'myserver.log',
+  pid_path: 'myserver.pid',
+  worker_type: 'process',
+  workers: 4,
+  bind: '0.0.0.0',
+  port: 9071,
+})
+se.run
+```
+
+
+### Multiprocess server on Windows and JRuby platform
+
+Above **worker_type=process** depends on `fork` system call, which doesn't work on Windows or JRuby platform.
+ServerEngine provides **worker_type=spawn** for those platforms (This is still EXPERIMENTAL). However, unfortunately, you need to implement different worker module because `worker_type=spawn` is not compatible with **worker_type=process** in terms of API.
+
+What you need to implement at least to use worker_type=spawn is `spawn(process_manager)` method. You will call `process_manager.spawn` at the method, where `spawn` is same with `Process.spawn` excepting return value.
+
+```ruby
+module MyWorker
+  def spawn(process_manager)
+    env = {
+      'SERVER_ENGINE_CONFIG' => config.to_json
+    }
+    script = %[
+      require 'serverengine'
+      require 'json'
+
+      conf = JSON.parse(ENV['SERVER_ENGINE_CONFIG'], symbolize_names: true)
+      logger = ServerEngine::DaemonLogger.new(conf[:log] || STDOUT, conf)
+
+      @stop = false
+      trap(:SIGTERM) { @stop = true }
+      trap(:SIGINT) { @stop = true }
+
+      until @stop
+        logger.info 'Awesome work!'
+        sleep 1
+      end
+    ]
+    process_manager.spawn(env, "ruby", "-e", script)
+  end
+end
+
+se = ServerEngine.create(nil, MyWorker, {
+  worker_type: 'spawn',
+  log: 'myserver.log',
 })
 se.run
 ```
@@ -129,10 +170,10 @@ ServerEngine logger rotates logs by 1MB and keeps 5 generations by default.
 
 ```ruby
 se = ServerEngine.create(MyServer, MyWorker, {
-  :log => 'myserver.log',
-  :log_level => 'debug',
-  :log_rotate_age => 5,
-  :log_rotate_size => 1*1024*1024,
+  log: 'myserver.log',
+  log_level: 'debug',
+  log_rotate_age: 5,
+  log_rotate_size: 1*1024*1024,
 })
 se.run
 ```
@@ -154,9 +195,9 @@ Supervisor process runs as the parent process of the server process and monitor
 
 ```ruby
 se = ServerEngine.create(nil, MyWorker, {
-  :daemonize => true,
-  :pid_path => 'myserver.pid',
-  :supervisor => true,  # enable supervisor process
+  daemonize: true,
+  pid_path: 'myserver.pid',
+  supervisor: true,  # enable supervisor process
 })
 se.run
 ```
@@ -229,8 +270,8 @@ end
 
 se = ServerEngine.create(nil, MyWorker) do
   YAML.load_file("config.yml").merge({
-    :daemonize => true,
-    :worker_type => 'process',
+    daemonize: true,
+    worker_type: 'process',
   })
 end
 se.run
@@ -264,8 +305,8 @@ end
 
 se = ServerEngine.create(nil, MyWorker) do
   YAML.load_file(config).merge({
-    :daemonize => true,
-    :worker_type => 'process'
+    daemonize: true,
+    worker_type: 'process'
   })
 end
 se.run
@@ -276,13 +317,16 @@ se.run
 
 ### Worker module
 
+Available methods are different depending on `worker_type`.
+
 - interface
   - `initialize` is called in the parent process (or thread) in contrast to the other methods
-  - `before_fork` is called before fork for each worker process (available only if `worker_type` is "process" or "thread")
-  - `run` is the required method
-  - `stop` is called when TERM signal is received
-  - `reload` is called when USR2 signal is received
-  - `after_start` is called after starting the worker process in the parent process (or thread) (available only if `worker_type` is "process" or "thread")
+  - `before_fork` is called before fork for each worker process [`worker_type` = "thread", "process"]
+  - `run` is the required method for `worker_type` = "embedded", "thread", "process"
+  - `spawn(process_manager)` is the required method for `worker_type` = "spawn". Should call `process_manager.spawn([env,] command... [,options])`.
+  - `stop` is called when TERM signal is received [`worker_type` = "embedded", "thread", "process"]
+  - `reload` is called when USR2 signal is received [`worker_type` = "embedded", "thread", "process"]
+  - `after_start` is called after starting the worker process in the parent process (or thread) [`worker_type` = "thread", "process", "spawn"]
 - api
   - `server` server instance
   - `config` configuration
@@ -296,7 +340,7 @@ se.run
   - `initialize` is called in the parent process in contrast to the other methods
   - `before_run` is called before starting workers
   - `after_run` is called before shutting down
-  - `after_start` is called after starting the server process in the parent process (available only if `supervisor` parameter is true)
+  - `after_start` is called after starting the server process in the parent process (available if `supervisor` parameter is true)
 - hook points (call `super` in these methods)
   - `reload_config`
   - `stop(stop_graceful)`
@@ -312,7 +356,8 @@ ServerEngine supports 3 worker types:
 
 - **embedded**: uses a thread to run worker module (default). This type doesn't support immediate shutdown or immediate restart.
 - **thread**: uses threads to run worker modules. This type doesn't support immediate shutdown or immediate restart.
-- **process**: uses processes to run worker modules. This type doesn't work on Win32 platform.
+- **process**: uses processes to run worker modules. This type doesn't work on Windows or JRuby platform.
+- **spawn**: uses processes to run worker modules. This type works on Windows and JRuby platform but available interface of worker module is limited (See also Worker module section).
 
 
 ## Signals
@@ -352,7 +397,7 @@ Graceful shutdown and restart call `Worker#stop` method and wait for completion
   - **workers** sets number of workers (default: 1) [dynamic reloadable]
   - **start_worker_delay** sets wait time before starting a new worker (default: 0) [dynamic reloadable]
   - **start_worker_delay_rand** randomizes start_worker_delay at this ratio (default: 0.2) [dynamic reloadable]
-- Multiprocess server: available only when `worker_type` is "process" [dynamic reloadable]
+- Multiprocess server: available only when `worker_type` is "process"
   - **worker_process_name** changes process name ($0) of workers [dynamic reloadable]
   - **worker_heartbeat_interval** sets interval of heartbeats in seconds (default: 1.0) [dynamic reloadable]
   - **worker_heartbeat_timeout** sets timeout of heartbeat in seconds (default: 180) [dynamic reloadable]
@@ -362,6 +407,9 @@ Graceful shutdown and restart call `Worker#stop` method and wait for completion
   - **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]
+- 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)
 - Logger
   - **log** sets path to log file. Set "-" for STDOUT (default: STDERR) [dynamic reloadable]
   - **log_level** log level: trace, debug, info, warn, error or fatal. (default: debug) [dynamic reloadable]

data/lib/serverengine.rb

@@ -33,6 +33,7 @@ module ServerEngine
     :MultiWorkerServer => 'serverengine/multi_worker_server',
     :MultiProcessServer => 'serverengine/multi_process_server',
     :MultiThreadServer => 'serverengine/multi_thread_server',
+    :MultiSpawnServer => 'serverengine/multi_spawn_server',
     :ProcessManager => 'serverengine/process_manager',
     :Worker => 'serverengine/worker',
     :VERSION => 'serverengine/version',

data/lib/serverengine/multi_spawn_server.rb

@@ -0,0 +1,87 @@
+#
+# ServerEngine
+#
+# Copyright (C) 2012-2013 Sadayuki Furuhashi
+#
+#    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.
+#
+module ServerEngine
+
+  class MultiSpawnServer < MultiWorkerServer
+    def initialize(worker_module, load_config_proc={}, &block)
+      @pm = ProcessManager.new(
+        auto_tick: false,
+        graceful_kill_signal: Daemon::Signals::GRACEFUL_STOP,
+        immediate_kill_signal: Daemon::Signals::IMMEDIATE_STOP,
+        enable_heartbeat: false,
+      )
+
+      super(worker_module, load_config_proc, &block)
+
+      @reload_signal = @config[:worker_reload_signal]
+    end
+
+    def run
+      super
+    ensure
+      @pm.close
+    end
+
+    def logger=(logger)
+      super
+      @pm.logger = logger
+    end
+
+    private
+
+    def reload_config
+      super
+
+      @pm.configure(@config, prefix: 'worker_')
+
+      nil
+    end
+
+    def start_worker(wid)
+      w = create_worker(wid)
+
+      w.before_fork
+      begin
+        pmon = w.spawn(@pm)
+      ensure
+        w.after_start
+      end
+
+      return WorkerMonitor.new(w, wid, pmon, @reload_signal)
+    end
+
+    def wait_tick
+      @pm.tick(0.5)
+    end
+
+    class WorkerMonitor < MultiProcessServer::WorkerMonitor
+      def initialize(worker, wid, pmon, reload_signal)
+        super(worker, wid, pmon)
+        @reload_signal = reload_signal
+      end
+
+      def send_reload
+        if @reload_signal
+          @pmon.send_signal(@reload_signal) if @pmon
+        end
+        nil
+      end
+    end
+  end
+
+end

data/lib/serverengine/multi_thread_server.rb

@@ -58,6 +58,7 @@ module ServerEngine
             ServerEngine.dump_uncaught_error(e)
           end
         end
+        nil
       end
 
       def join

data/lib/serverengine/process_manager.rb

@@ -146,7 +146,7 @@ module ServerEngine
       rpipe, wpipe = new_pipe_pair
 
       begin
-        options[wpipe.fileno] = wpipe
+        options[[wpipe.fileno]] = wpipe
         if @enable_heartbeat
           env['SERVERENGINE_HEARTBEAT_PIPE'] = wpipe.fileno.to_s
         end

data/lib/serverengine/server.rb

@@ -40,6 +40,7 @@ module ServerEngine
     end
 
     def stop(stop_graceful)
+      @logger.info "Received #{stop_graceful ? 'graceful' : 'immediate'} stop" if @logger
       @stop = true
       nil
     end
@@ -48,12 +49,14 @@ module ServerEngine
     end
 
     def restart(stop_graceful)
+      @logger.info "Received #{stop_graceful ? 'graceful' : 'immediate'} restart" if @logger
       reload_config
       @logger.reopen! if @logger
       nil
     end
 
     def reload
+      @logger.info "Received reload" if @logger
       reload_config
       @logger.reopen! if @logger
       nil

data/lib/serverengine/supervisor.rb

@@ -72,6 +72,8 @@ module ServerEngine
         server_class = MultiProcessServer
       when 'thread'
         server_class = MultiThreadServer
+      when 'spawn'
+        server_class = MultiSpawnServer
       else
         raise ArgumentError, "unexpected :worker_type option #{wt}"
       end

data/lib/serverengine/version.rb

@@ -1,3 +1,3 @@
 module ServerEngine
-  VERSION = "1.5.9"
+  VERSION = "1.5.10"
 end

data/lib/serverengine/worker.rb

@@ -20,13 +20,16 @@ module ServerEngine
   class Worker
     def initialize(server, worker_id)
       @server = server
-      @config = server.config
       @logger = @server.logger
       @worker_id = worker_id
     end
 
     attr_reader :server, :worker_id
-    attr_accessor :config, :logger
+    attr_accessor :logger
+
+    def config
+      @server.config
+    end
 
     def before_fork
     end
@@ -35,6 +38,10 @@ module ServerEngine
       raise NoMethodError, "Worker#run method is not implemented"
     end
 
+    def spawn(process_manager)
+      raise NoMethodError, "Worker#spawn(process_manager) method is required for worker_type=spawn"
+    end
+
     def stop
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serverengine
 version: !ruby/object:Gem::Version
-  version: 1.5.9
+  version: 1.5.10
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2014-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sigdump
@@ -75,6 +75,7 @@ files:
 - lib/serverengine/daemon_logger.rb
 - lib/serverengine/embedded_server.rb
 - lib/serverengine/multi_process_server.rb
+- lib/serverengine/multi_spawn_server.rb
 - lib/serverengine/multi_thread_server.rb
 - lib/serverengine/multi_worker_server.rb
 - lib/serverengine/process_manager.rb