serverengine 2.0.0pre1-x64-mingw32

data/lib/serverengine/utils.rb

@@ -0,0 +1,62 @@
+#
+# 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
+
+  IS_WINDOWS = /mswin|mingw/ === RUBY_PLATFORM
+  private_constant :IS_WINDOWS
+
+  def self.windows?
+    IS_WINDOWS
+  end
+
+  module ClassMethods
+    def dump_uncaught_error(e)
+      STDERR.write "Unexpected error #{e}\n"
+      e.backtrace.each {|bt|
+        STDERR.write "  #{bt}\n"
+      }
+      nil
+    end
+
+    def format_signal_name(n)
+      Signal.list.each_pair {|k,v|
+        return "SIG#{k}" if n == v
+      }
+      return n
+    end
+
+    def format_join_status(code)
+      case code
+      when Process::Status
+        if code.signaled?
+          "signal #{format_signal_name(code.termsig)}"
+        else
+          "status #{code.exitstatus}"
+        end
+      when Exception
+        "exception #{code}"
+      when nil
+        "unknown reason"
+      end
+    end
+
+  end
+
+  extend ClassMethods
+
+end

data/lib/serverengine/version.rb

@@ -0,0 +1,3 @@
+module ServerEngine
+  VERSION = "2.0.0pre1"
+end

data/lib/serverengine/winsock.rb

@@ -0,0 +1,128 @@
+#
+# 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
+  module WinSock
+
+    require 'fiddle/import'
+    require 'fiddle/types'
+    require 'socket'
+
+    extend Fiddle::Importer
+
+    dlload "ws2_32.dll"
+    include Fiddle::Win32Types
+
+    extern "int WSASocketA(int, int, int, void *, int, DWORD)"
+    extern "long inet_addr(char *)"
+    extern "int bind(int, void *, int)"
+    extern "int listen(int, int)"
+    extern "int WSADuplicateSocketA(int, DWORD, void *)"
+    extern "int WSAGetLastError()"
+
+    SockaddrIn = struct(["short sin_family",
+                         "short sin_port",
+                         "long sin_addr",
+                         "char sin_zero[8]",
+                        ])
+
+    WSAPROTOCOL_INFO = struct(["DWORD dwServiceFlags1",
+                               "DWORD dwServiceFlags2",
+                               "DWORD dwServiceFlags3",
+                               "DWORD dwServiceFlags4",
+                               "DWORD dwProviderFlags",
+                               "DWORD Data1",
+                               "WORD  Data2",
+                               "WORD  Data3",
+                               "BYTE  Data4[8]",
+                               "DWORD dwCatalogEntryId",
+                               "int ChainLen",
+                               "DWORD ChainEntries[7]",
+                               "int iVersion",
+                               "int iAddressFamily",
+                               "int iMaxSockAddr",
+                               "int iMinSockAddr",
+                               "int iSocketType",
+                               "int iProtocol",
+                               "int iProtocolMaxOffset",
+                               "int iNetworkByteOrder",
+                               "int iSecurityScheme",
+                               "DWORD dwMessageSize",
+                               "DWORD dwProviderReserved",
+                               "char szProtocol[256]",
+                              ])
+
+    class WSAPROTOCOL_INFO
+      def self.from_bin(bin)
+        proto = malloc
+        proto.to_ptr.ref.ptr[0, size] = bin
+        proto
+      end
+
+      def to_bin
+        to_ptr.to_s
+      end
+    end
+
+    INVALID_SOCKET = -1
+  end
+
+  module RbWinSock
+    extend Fiddle::Importer
+
+    dlload "kernel32"
+    extern "int GetModuleFileNameA(int, char *, int)"
+    extern "int CloseHandle(int)"
+
+    ruby_bin_path_buf = Fiddle::Pointer.malloc(1000)
+    GetModuleFileNameA(0, ruby_bin_path_buf, ruby_bin_path_buf.size)
+
+    ruby_bin_path = ruby_bin_path_buf.to_s.gsub(/\\/, '/')
+    ruby_dll_paths = File.dirname(ruby_bin_path) + '/*msvcr*ruby*.dll'
+    ruby_dll_path = Dir.glob(ruby_dll_paths).first
+    dlload ruby_dll_path
+
+    extern "int rb_w32_map_errno(int)"
+    extern "void rb_syserr_fail(int, char *)"
+
+    def self.raise_last_error(name)
+      errno = rb_w32_map_errno(WinSock.WSAGetLastError)
+      rb_syserr_fail(errno, name)
+    end
+
+    extern "int rb_w32_wrap_io_handle(int, int)"
+
+    def self.wrap_io_handle(sock_class, handle, flags)
+      begin
+        fd = rb_w32_wrap_io_handle(handle, flags)
+        if fd < 0
+          raise_last_error("rb_w32_wrap_io_handle(3)")
+        end
+
+        sock = sock_class.for_fd(fd)
+        wrapped = true
+        sock.define_singleton_method(:handle) { handle }
+
+        return sock
+      ensure
+        unless wrapped
+          WinSock.CloseHandle(handle)
+        end
+      end
+    end
+  end
+end

data/lib/serverengine/worker.rb

@@ -0,0 +1,81 @@
+#
+# 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 'serverengine/signals'
+require 'serverengine/signal_thread'
+
+module ServerEngine
+
+  class Worker
+    def initialize(server, worker_id)
+      @server = server
+      @logger = @server.logger
+      @worker_id = worker_id
+    end
+
+    attr_reader :server, :worker_id
+    attr_accessor :logger
+
+    def config
+      @server.config
+    end
+
+    def before_fork
+    end
+
+    def run
+      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
+
+    def reload
+    end
+
+    def after_start
+    end
+
+    def install_signal_handlers
+      w = self
+      SignalThread.new do |st|
+        st.trap(Signals::GRACEFUL_STOP) { w.stop }
+        st.trap(Signals::IMMEDIATE_STOP, 'SIG_DFL')
+
+        st.trap(Signals::GRACEFUL_RESTART) { w.stop }
+        st.trap(Signals::IMMEDIATE_RESTART, 'SIG_DFL')
+
+        st.trap(Signals::RELOAD) {
+          w.logger.reopen!
+          w.reload
+        }
+        st.trap(Signals::DETACH) { w.stop }
+
+        st.trap(Signals::DUMP) { Sigdump.dump }
+      end
+    end
+
+    def main
+      run
+    end
+  end
+
+end

data/serverengine.gemspec

@@ -0,0 +1,37 @@
+require File.expand_path 'lib/serverengine/version', File.dirname(__FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "serverengine"
+  gem.version       = ServerEngine::VERSION
+
+  gem.authors       = ["Sadayuki Furuhashi"]
+  gem.email         = ["frsyuki@gmail.com"]
+  gem.description   = %q{A framework to implement robust multiprocess servers like Unicorn}
+  gem.summary       = %q{ServerEngine - multiprocess server framework}
+  gem.homepage      = "https://github.com/fluent/serverengine"
+  gem.license       = "Apache 2.0"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.has_rdoc = false
+
+  gem.required_ruby_version = ">= 2.1.0"
+
+  gem.add_dependency "sigdump", ["~> 0.2.2"]
+
+  gem.add_development_dependency "rake", [">= 0.9.2"]
+  gem.add_development_dependency "rspec", ["~> 2.13.0"]
+
+  gem.add_development_dependency 'rake-compiler-dock', ['~> 0.5.0']
+  gem.add_development_dependency 'rake-compiler', ['~> 0.9.4']
+
+  # build gem for a certain platform. see also Rakefile
+  fake_platform = ENV['GEM_BUILD_FAKE_PLATFORM'].to_s
+  gem.platform = fake_platform unless fake_platform.empty?
+  if /mswin|mingw/ =~ fake_platform || (/mswin|mingw/ =~ RUBY_PLATFORM && fake_platform.empty?)
+    # windows dependencies
+    gem.add_runtime_dependency("windows-pr", ["~> 1.2.5"])
+  end
+end

data/spec/blocking_flag_spec.rb

@@ -0,0 +1,59 @@
+
+describe ServerEngine::BlockingFlag do
+  subject { BlockingFlag.new }
+
+  it 'set and reset' do
+    should_not be_set
+    subject.set!
+    should be_set
+    subject.reset!
+    should_not be_set
+  end
+
+  it 'set! and reset! return whether it toggled the state' do
+    subject.reset!.should == false
+    subject.set!.should == true
+    subject.set!.should == false
+    subject.reset!.should == true
+  end
+
+  it 'wait_for_set timeout' do
+    start = Time.now
+
+    subject.wait_for_set(0.01)
+    elapsed = Time.now - start
+
+    elapsed.should >= 0.01
+  end
+
+  it 'wait_for_reset timeout' do
+    subject.set!
+
+    start = Time.now
+
+    subject.wait_for_reset(0.01)
+    elapsed = Time.now - start
+
+    elapsed.should >= 0.01
+  end
+
+  it 'wait' do
+    start = Time.now
+    elapsed = nil
+
+    started = BlockingFlag.new
+    t = Thread.new do
+      started.set!
+      Thread.pass
+      subject.wait_for_set(1)
+      elapsed = Time.now - start
+    end
+    started.wait_for_set
+
+    subject.set!
+    t.join
+
+    elapsed.should_not be_nil
+    elapsed.should < 0.5
+  end
+end

data/spec/daemon_logger_spec.rb

@@ -0,0 +1,175 @@
+require 'stringio'
+
+describe ServerEngine::DaemonLogger do
+  before { FileUtils.rm_rf("tmp") }
+  before { FileUtils.mkdir_p("tmp") }
+  before { FileUtils.rm_f("tmp/se1.log") }
+  before { FileUtils.rm_f("tmp/se2.log") }
+  before { FileUtils.rm_f Dir["tmp/se3.log.**"] }
+  before { FileUtils.rm_f Dir["tmp/se4.log.**"] }
+
+  subject { DaemonLogger.new("tmp/se1.log", level: 'trace') }
+
+  it 'reopen' do
+    subject.warn "ABCDEF"
+    File.open('tmp/se1.log', "w") {|f| }
+
+    subject.warn "test2"
+    File.read('tmp/se1.log').should_not =~ /ABCDEF/
+
+    subject.reopen!
+    subject.warn "test3"
+    File.read('tmp/se1.log').should =~ /test3/
+  end
+
+  it 'reset path' do
+    subject.logdev = 'tmp/se2.log'
+    subject.warn "test"
+
+    File.read('tmp/se2.log').should =~ /test$/
+  end
+
+  it 'default level is debug' do
+    subject.debug 'debug'
+    File.read('tmp/se1.log').should =~ /debug$/
+  end
+
+  it 'level set by int' do
+    subject.level = Logger::FATAL
+    subject.level.should == Logger::FATAL
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == false
+    subject.error?.should == false
+    subject.fatal?.should == true
+
+    subject.level = Logger::ERROR
+    subject.level.should == Logger::ERROR
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == false
+    subject.error?.should == true
+    subject.fatal?.should == true
+
+    subject.level = Logger::WARN
+    subject.level.should == Logger::WARN
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
+
+    subject.level = Logger::INFO
+    subject.level.should == Logger::INFO
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
+
+    subject.level = Logger::DEBUG
+    subject.level.should == Logger::DEBUG
+    subject.trace?.should == false
+    subject.debug?.should == true
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
+
+    subject.level = DaemonLogger::TRACE
+    subject.level.should == DaemonLogger::TRACE
+    subject.trace?.should == true
+    subject.debug?.should == true
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
+  end
+
+  it 'level set by string' do
+    subject.level = 'fatal'
+    subject.level.should == Logger::FATAL
+
+    subject.level = 'error'
+    subject.level.should == Logger::ERROR
+
+    subject.level = 'warn'
+    subject.level.should == Logger::WARN
+
+    subject.level = 'info'
+    subject.level.should == Logger::INFO
+
+    subject.level = 'debug'
+    subject.level.should == Logger::DEBUG
+
+    subject.level = 'trace'
+    subject.level.should == DaemonLogger::TRACE
+  end
+
+  it 'unknown level' do
+    lambda { subject.level = 'unknown' }.should raise_error(ArgumentError)
+  end
+
+  it 'rotation' do
+    log = DaemonLogger.new("tmp/se3.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10000)
+    # 100 bytes
+    log.warn "test1"*20
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.0").should == false
+
+    # 10000 bytes
+    100.times { log.warn "test2"*20 }
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.0").should == true
+    File.read("tmp/se3.log.0") =~ /test2$/
+
+    # 10000 bytes
+    100.times { log.warn "test3"*20 }
+    File.exist?("tmp/se3.log").should == true
+    File.exist?("tmp/se3.log.1").should == true
+    File.exist?("tmp/se3.log.2").should == false
+
+    log.warn "test4"*20
+    File.read("tmp/se3.log").should =~ /test4$/
+    File.read("tmp/se3.log.0").should =~ /test3$/
+  end
+
+  it 'IO logger' do
+    io = StringIO.new
+    io.should_receive(:write)
+    io.should_not_receive(:reopen)
+
+    log = DaemonLogger.new(io)
+    log.debug "stdout logging test"
+    log.reopen!
+  end
+
+  it 'inter-process locking on rotation' do
+    pending "fork is not implemented in Windows" if ServerEngine.windows?
+
+    log = DaemonLogger.new("tmp/se4.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10)
+    r, w = IO.pipe
+    $stderr = w # To capture #warn output in DaemonLogger
+    pid1 = Process.fork do
+      10.times do
+        log.info '0' * 15
+      end
+    end
+    pid2 = Process.fork do
+      10.times do
+        log.info '0' * 15
+      end
+    end
+    Process.waitpid pid1
+    Process.waitpid pid2
+    w.close
+    stderr = r.read
+    r.close
+    $stderr = STDERR
+    stderr.should_not =~ /(log shifting failed|log writing failed|log rotation inter-process lock failed)/
+  end
+end