serverengine 2.0.0pre1-x64-mingw32

data/Rakefile

@@ -0,0 +1,26 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+require 'rake/clean'
+
+require 'rspec/core/rake_task'
+
+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
+

data/appveyor.yml

@@ -0,0 +1,24 @@
+---
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - ruby --version
+  - gem --version
+  - bundle install
+build: off
+test_script:
+  - bundle exec rake -rdevkit
+
+environment:
+  matrix:
+    - 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"
+      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.rb

@@ -0,0 +1,46 @@
+#
+# 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
+
+  require 'sigdump'
+
+  require 'serverengine/version'
+
+  require 'serverengine/utils' # ServerEngine.windows? and other util methods
+
+  require 'serverengine/daemon'
+  require 'serverengine/supervisor'
+  require 'serverengine/server'
+  require 'serverengine/worker'
+  require 'serverengine/socket_manager'
+
+  def self.create(server_module, worker_module, load_config_proc={}, &block)
+    Daemon.new(server_module, worker_module, load_config_proc, &block)
+  end
+
+  def self.ruby_bin_path
+    if ServerEngine.windows?
+      require 'windows/library'
+      ruby_path = "\0" * 256
+      Windows::Library::GetModuleFileName.call(0, ruby_path, 256)
+      return ruby_path.rstrip.gsub(/\\/, '/')
+    else
+      return File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["RUBY_INSTALL_NAME"]) + RbConfig::CONFIG["EXEEXT"]
+    end
+  end
+end

data/lib/serverengine/blocking_flag.rb

@@ -0,0 +1,77 @@
+#
+# 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.
+#
+require 'thread'
+
+module ServerEngine
+  class BlockingFlag
+    def initialize
+      @set = false
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+    end
+
+    def set!
+      toggled = false
+      @mutex.synchronize do
+        unless @set
+          @set = true
+          toggled = true
+        end
+        @cond.broadcast
+      end
+      return toggled
+    end
+
+    def reset!
+      toggled = false
+      @mutex.synchronize do
+        if @set
+          @set = false
+          toggled = true
+        end
+        @cond.broadcast
+      end
+      return toggled
+    end
+
+    def set?
+      @set
+    end
+
+    def wait_for_set(timeout=nil)
+      @mutex.synchronize do
+        unless @set
+          @cond.wait(@mutex, timeout)
+        end
+        return @set
+      end
+    end
+
+    alias_method :wait, :wait_for_set
+
+    def wait_for_reset(timeout=nil)
+      @mutex.synchronize do
+        if @set
+          @cond.wait(@mutex, timeout)
+        end
+        return !@set
+      end
+    end
+  end
+
+end

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