riser 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e26229a7967de4c918147e37649406d03d58cdee805eace413c4954e620a721a
-  data.tar.gz: fb420260978813955e399b828df5172a339acc60d5682eeb4173c6a93318d598
+  metadata.gz: cb038d800b97433c3499cb880acc77e0513d6dab1d18eace369137a98870cd8b
+  data.tar.gz: e4b2a6ab5cc93fa3e84c0dcdd53038e879d54e51ee2007f702a1afeb10c45409
 SHA512:
-  metadata.gz: 647c1ea473d0beac010774c07c69166f617236d1e4be65741925533274a8c909ccc870f6d69b3c2fe461a0026d9d0fb2edb7424be990ce695a644e2042078e53
-  data.tar.gz: c2256038205ede27cd679385965a2f18785777edfc5e03a6e43fd9f3a0bbd412f3628efdcca0b1c0fb0ca3712d44fb0513dac2b474ac44ea9c0f6f9a67a63e0f
+  metadata.gz: 4b5fdb35eb7ea3c7f9b535e5d857acb7bb85b671db989ed90123ead48d1079606afbe35a9f0c970a4ddfe62c21c32246468406c33739fad5a037b5e61b92d525
+  data.tar.gz: 71a67816a2048bd849eb12801a40c8114b446bafbbde210e253c172af915026d524c976f6068472ebf747af2b9a0ad6b79d9e3344b74b58bf96c874337db3368

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 TOKI Yoshinori
+Copyright (c) 2018-2019 TOKI Yoshinori
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -463,7 +463,8 @@ Riser::Daemon.start_daemon(daemonize: false,
           socket << 'pid: ' << services.call_service(:pid_single) << "\n"
         when '/sticky'
           key = query || 'default'
-          socket << 'key: ' << key << ', pid: ' << services.call_service(:pid_stickty, key) << "\n"
+          socket << 'key: ' << key << "\n"
+          socket << 'pid: ' << services.call_service(:pid_stickty, key) << "\n"
         else
           socket << "unknown path: #{path}\n"
         end
@@ -587,17 +588,23 @@ the web service's result of 'sticky process' pattern.
 
 ```
 $ curl http://localhost:8000/sticky
-key: default, pid: 3181
+key: default
+pid: 3181
 $ curl http://localhost:8000/sticky
-key: default, pid: 3181
+key: default
+pid: 3181
 $ curl http://localhost:8000/sticky?foo
-key: foo, pid: 3179
+key: foo
+pid: 3179
 $ curl http://localhost:8000/sticky?foo
-key: foo, pid: 3179
+key: foo
+pid: 3179
 $ curl http://localhost:8000/sticky?bar
-key: bar, pid: 3185
+key: bar
+pid: 3185
 $ curl http://localhost:8000/sticky?bar
-key: bar, pid: 3185
+key: bar
+pid: 3185
 ```
 
 In the 'sticky process' pattern, the same process id will be given for
@@ -651,7 +658,8 @@ Riser::Daemon.start_daemon(daemonize: false,
           socket << 'pid: ' << services.call_service(:pid_single) << "\n"
         when '/sticky'
           key = query || 'default'
-          socket << 'key: ' << key << ', pid: ' << services.call_service(:pid_stickty, key) << "\n"
+          socket << 'key: ' << key << "\n"
+          socket << 'pid: ' << services.call_service(:pid_stickty, key) << "\n"
         else
           socket << "unknown path: #{path}\n"
         end
@@ -711,17 +719,23 @@ pid: 3855
 
 ```
 $ curl http://localhost:8000/sticky
-key: default, pid: 3855
+key: default
+pid: 3855
 $ curl http://localhost:8000/sticky
-key: default, pid: 3855
+key: default
+pid: 3855
 $ curl http://localhost:8000/sticky?foo
-key: foo, pid: 3855
+key: foo
+pid: 3855
 $ curl http://localhost:8000/sticky?foo
-key: foo, pid: 3855
+key: foo
+pid: 3855
 $ curl http://localhost:8000/sticky?bar
-key: bar, pid: 3855
+key: bar
+pid: 3855
 $ curl http://localhost:8000/sticky?bar
-key: bar, pid: 3855
+key: bar
+pid: 3855
 ```
 
 ### dRuby Services Callbacks
@@ -819,8 +833,8 @@ Riser::Daemon.start_daemon(daemonize: false,
                                         builder.at_create{|key|
                                           PStore.new("simple_key_count-#{key}.pstore", true)
                                         }
-                                        builder.at_destroy{
-                                          # nothing to do.
+                                        builder.at_destroy{|pstore|
+                                          # nothing to do about `pstore'.
                                         }
                                       })
 

data/example/local_services.rb

@@ -42,7 +42,8 @@ Riser::Daemon.start_daemon(daemonize: false,
           socket << 'pid: ' << services.call_service(:pid_single) << "\n"
         when '/sticky'
           key = query || 'default'
-          socket << 'key: ' << key << ', pid: ' << services.call_service(:pid_stickty, key) << "\n"
+          socket << 'key: ' << key << "\n"
+          socket << 'pid: ' << services.call_service(:pid_stickty, key) << "\n"
         else
           socket << "unknown path: #{path}\n"
         end

data/example/simple_key_count.rb

@@ -15,8 +15,8 @@ Riser::Daemon.start_daemon(daemonize: false,
                                         builder.at_create{|key|
                                           PStore.new("simple_key_count-#{key}.pstore", true)
                                         }
-                                        builder.at_destroy{
-                                          # nothing to do.
+                                        builder.at_destroy{|pstore|
+                                          # nothing to do about `pstore'.
                                         }
                                       })
 

data/example/simple_services.rb

@@ -42,7 +42,8 @@ Riser::Daemon.start_daemon(daemonize: false,
           socket << 'pid: ' << services.call_service(:pid_single) << "\n"
         when '/sticky'
           key = query || 'default'
-          socket << 'key: ' << key << ', pid: ' << services.call_service(:pid_stickty, key) << "\n"
+          socket << 'key: ' << key << "\n"
+          socket << 'pid: ' << services.call_service(:pid_stickty, key) << "\n"
         else
           socket << "unknown path: #{path}\n"
         end

data/lib/riser/daemon.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+require 'fileutils'
 require 'logger'
 require 'syslog/logger'
 require 'yaml'
@@ -35,17 +36,19 @@ module Riser
 
   class RootProcess
     class SystemOperation
-      def initialize(logger, module_Process: Process, class_IO: IO)
+      def initialize(logger, module_FileUtils: FileUtils, module_Process: Process, class_IO: IO, class_File: File)
         @logger = logger
+        @FileUtils = module_FileUtils
         @Process = module_Process
         @IO = class_IO
+        @File = class_File
       end
 
       def get_server_address(sockaddr_get)
         begin
           address_config = sockaddr_get.call
         rescue
-          @logger.error("failed to get server address [#{$!}]")
+          @logger.error("failed to get server address [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           return
         end
@@ -61,7 +64,37 @@ module Riser
         begin
           server_address.open_server
         rescue
-          @logger.error("failed to open server socket: #{server_address} [#{$!}]")
+          @logger.error("failed to open server socket: #{server_address} [#{$!} (#{$!.class})]")
+          @logger.debug($!) if @logger.debug?
+          nil
+        end
+      end
+
+      def listen(server_socket, backlog)
+        begin
+          server_socket.listen(backlog)
+        rescue
+          @logger.error("failed to listen(2) server socket with backlog: #{backlog} [#{$!} (#{$!.class})]")
+          @logger.debug($!) if @logger.debug?
+          nil
+        end
+      end
+
+      def chmod(mode, path)
+        begin
+          @FileUtils.chmod(mode, path)
+        rescue
+          @logger.error("failed to chmod(2): #{'%04o' % mode} #{path} [#{$!} (#{$!.class})]")
+          @logger.debug($!) if @logger.debug?
+          nil
+        end
+      end
+
+      def chown(owner, group, path)
+        begin
+          @FileUtils.chown(owner, group, path)
+        rescue
+          @logger.error("failed to chown(2): <#{owner}> <#{group}> <#{path}> [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -71,7 +104,7 @@ module Riser
         begin
           @Process.kill(signal, pid)
         rescue
-          @logger.error("failed to send signal (#{signal}) to process (pid: #{pid}) [#{$!}]")
+          @logger.error("failed to send signal (#{signal}) to process (pid: #{pid}) [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -81,7 +114,7 @@ module Riser
         begin
           @Process.wait(pid, flags)
         rescue
-          @logger.error("failed to wait(2) for process (pid: #{pid}) [#{$!}]")
+          @logger.error("failed to wait(2) for process (pid: #{pid}) [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -91,7 +124,7 @@ module Riser
         begin
           @IO.pipe
         rescue
-          @logger.error("failed to pipe(2) [#{$!}]")
+          @logger.error("failed to pipe(2) [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -101,7 +134,7 @@ module Riser
         begin
           @Process.fork{ yield }
         rescue
-          @logger.error("failed to fork(2) [#{$!}]")
+          @logger.error("failed to fork(2) [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -111,7 +144,7 @@ module Riser
         begin
           io.gets
         rescue
-          @logger.error("failed to get line from #{io.inspect} [#{$!}]")
+          @logger.error("failed to get line from #{io.inspect} [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -122,7 +155,17 @@ module Riser
           io.close
           io
         rescue
-          @logger.error("failed to close(2) #{io.inspect} [#{$!}]")
+          @logger.error("failed to close(2) #{io.inspect} [#{$!} (#{$!.class})]")
+          @logger.debug($!) if @logger.debug?
+          nil
+        end
+      end
+
+      def unlink(path)
+        begin
+          File.unlink(path)
+        rescue
+          @logger.error("failed to unlink(2): #{path} [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           nil
         end
@@ -258,7 +301,7 @@ module Riser
           Signal.trap(SIGNAL_STAT_GET_NO_RESET) { server.signal_stat_get(reset: false) }
           Signal.trap(SIGNAL_STAT_STOP) { server.signal_stat_stop }
         rescue
-          @logger.error("failed to setup server (pid: #{$$}) [#{$!}]")
+          @logger.error("failed to setup server (pid: #{$$}) [#{$!} (#{$!.class})]")
           @logger.debug($!) if @logger.debug?
           raise
         end
@@ -313,139 +356,242 @@ module Riser
       end
       @logger.info("open server socket: #{server_socket.local_address.inspect_sockaddr}")
 
-      unless (server_pid = run_server(server_socket)) then
-        @logger.fatal('failed to start daemon.')
-        return 1
-      end
-      @logger.info("server process start (pid: #{server_pid})")
-
-      @logger.info("start server polling (interval seconds: #{@server_polling_interval_seconds})")
-      until (@stop_state)
-        server_polling_sleep
-        if (server_pid) then
-          @logger.debug("server polling... (pid: #{server_pid})") if @logger.debug?
+      begin
+        if (server_address.backlog) then
+          if (@sysop.listen(server_socket, server_address.backlog)) then
+            @logger.info("server socket backlog: #{server_address.backlog}")
+          else
+            @logger.warn('server socket backlog is not changed.')
+          end
         else
-          @logger.debug('server polling...') if @logger.debug?
+          @logger.info('server socket backlog is default.')
         end
 
-        if (! server_pid || @sysop.wait(server_pid, Process::WNOHANG)) then
-          if (server_pid) then
-            @logger.warn("found server down (pid: #{server_pid}) and restart server.")
+        if (server_address.type == :unix) then
+          if (server_address.mode) then
+            if (@sysop.chmod(server_address.mode, server_address.path)) then
+              @logger.info("unix domain server socket mode: #{'%04o' % server_address.mode}")
+            else
+              @logger.warn('unix domain server socket mode is not changed.')
+            end
           else
-            @logger.warn('found server down and restart server.')
+            @logger.info('unix domain server socket mode is default.')
           end
-          if (server_pid = run_server(server_socket)) then
-            @logger.info("server process start (pid: #{server_pid})")
+
+          if (server_address.owner || server_address.group) then
+            if (@sysop.chown(server_address.owner, server_address.group, server_address.path)) then
+              @logger.info("unix domain server socket ownership: <#{server_address.owner}> <#{server_address.group}>")
+            else
+              @logger.warn('unix domain server socket ownership is not changed.')
+            end
+          else
+            @logger.info('unix domain server socket ownership is default.')
           end
         end
 
-        while (! @stop_state && server_pid && sig_ope = @signal_operation_queue.shift)
-          case (sig_ope)
-          when :restart_graceful, :restart_forced
-            if (next_server_address = @sysop.get_server_address(@sockaddr_get)) then
-              if (next_server_address != server_address) then
-                if (next_server_socket = @sysop.get_server_socket(next_server_address)) then
-                  @logger.info("open server socket: #{next_server_socket.local_address.inspect_sockaddr}")
-                  @logger.info("close server socket: #{server_socket.local_address.inspect_sockaddr}")
-                  @sysop.close(server_socket) or @logger.warn("failed to close server socket (#{server_address})")
-                  server_socket = next_server_socket
-                  server_address = next_server_address
-                else
-                  @logger.warn("server socket continue: #{server_socket.local_address.inspect_sockaddr}")
-                end
-              end
+        unless (server_pid = run_server(server_socket)) then
+          @logger.fatal('failed to start daemon.')
+          return 1
+        end
+        @logger.info("server process start (pid: #{server_pid})")
+
+        @logger.info("start server polling (interval seconds: #{@server_polling_interval_seconds})")
+        until (@stop_state)
+          server_polling_sleep
+          if (server_pid) then
+            @logger.debug("server polling... (pid: #{server_pid})") if @logger.debug?
+          else
+            @logger.debug('server polling...') if @logger.debug?
+          end
+
+          if (! server_pid || @sysop.wait(server_pid, Process::WNOHANG)) then
+            if (server_pid) then
+              @logger.warn("found server down (pid: #{server_pid}) and restart server.")
             else
-              @logger.warn("server socket continue: #{server_socket.local_address.inspect_sockaddr}")
+              @logger.warn('found server down and restart server.')
+            end
+            if (server_pid = run_server(server_socket)) then
+              @logger.info("server process start (pid: #{server_pid})")
             end
+          end
 
+          while (! @stop_state && server_pid && sig_ope = @signal_operation_queue.shift)
             case (sig_ope)
-            when :restart_graceful
-              @logger.info("server graceful restart (pid: #{server_pid})")
-            when :restart_forced
-              @logger.info("server forced restart (pid: #{server_pid})")
-            else
-              @logger.warn("internal warning: unknown signal operation <#{sig_ope.inspect}>")
-            end
+            when :restart_graceful, :restart_forced
+              if (next_server_address = @sysop.get_server_address(@sockaddr_get)) then
+                if (next_server_address.to_address == server_address.to_address) then
+                  if (next_server_address.to_option != server_address.to_option) then
+                    server_address = next_server_address
+                  end
+                else
+                  if (next_server_socket = @sysop.get_server_socket(next_server_address)) then
+                    @logger.info("open server socket: #{next_server_socket.local_address.inspect_sockaddr}")
+                    server_socket_local_address = server_socket.local_address # get local_address before close(2)
+                    if (@sysop.close(server_socket)) then
+                      @logger.info("close server socket: #{server_socket_local_address.inspect_sockaddr}") 
+                    else
+                      @logger.warn("failed to close server socket: #{server_socket_local_address.inspect_sockaddr}")
+                    end
+                    if (server_address.type == :unix) then
+                      if (@sysop.unlink(server_address.path)) then
+                        @logger.info("delete unix server socket: #{server_address}")
+                      else
+                        @logger.warn("failed to delete unix server socket: #{server_address}")
+                      end
+                    end
+                    server_socket = next_server_socket
+                    server_address = next_server_address
+                  else
+                    @logger.warn("server socket continue: #{server_socket.local_address.inspect_sockaddr}")
+                  end
+                end
+              else
+                @logger.warn("server socket continue: #{server_socket.local_address.inspect_sockaddr}")
+              end
 
-            if (next_pid = run_server(server_socket)) then
-              @logger.info("server process start (pid: #{next_pid})")
+              if (server_address.backlog) then
+                if (@sysop.listen(server_socket, server_address.backlog)) then
+                  @logger.info("server socket backlog: #{server_address.backlog}")
+                else
+                  @logger.warn('server socket backlog is not changed.')
+                end
+              else
+                @logger.info('server socket backlog is default.')
+              end
+
+              if (server_address.type == :unix) then
+                if (server_address.mode) then
+                  if (@sysop.chmod(server_address.mode, server_address.path)) then
+                    @logger.info("unix domain server socket mode: #{'%04o' % server_address.mode}")
+                  else
+                    @logger.warn('unix domain server socket mode is not changed.')
+                  end
+                else
+                  @logger.info('unix domain server socket mode is default.')
+                end
 
-              if (@server_restart_overlap_seconds > 0) then
-                @logger.info("server restart overlap (interval seconds: #{@server_restart_overlap_seconds})")
-                sleep(@server_restart_overlap_seconds)
+                if (server_address.owner || server_address.group) then
+                  if (@sysop.chown(server_address.owner, server_address.group, server_address.path)) then
+                    @logger.info("unix domain server socket ownership: <#{server_address.owner}> <#{server_address.group}>")
+                  else
+                    @logger.warn('unix domain server socket ownership is not changed.')
+                  end
+                else
+                  @logger.info('unix domain server socket ownership is default.')
+                end
               end
 
               case (sig_ope)
               when :restart_graceful
-                @logger.info("server graceful stop (pid: #{server_pid})")
-                server_stop_graceful(server_pid)
+                @logger.info("server graceful restart (pid: #{server_pid})")
               when :restart_forced
-                @logger.info("server forced stop (pid: #{server_pid})")
-                server_stop_forced(server_pid)
+                @logger.info("server forced restart (pid: #{server_pid})")
               else
                 @logger.warn("internal warning: unknown signal operation <#{sig_ope.inspect}>")
               end
 
-              @process_wait_count_table[server_pid] = 0
-              server_pid = next_pid
+              if (next_pid = run_server(server_socket)) then
+                @logger.info("server process start (pid: #{next_pid})")
+
+                if (@server_restart_overlap_seconds > 0) then
+                  @logger.info("server restart overlap (interval seconds: #{@server_restart_overlap_seconds})")
+                  sleep(@server_restart_overlap_seconds)
+                end
+
+                case (sig_ope)
+                when :restart_graceful
+                  @logger.info("server graceful stop (pid: #{server_pid})")
+                  server_stop_graceful(server_pid)
+                when :restart_forced
+                  @logger.info("server forced stop (pid: #{server_pid})")
+                  server_stop_forced(server_pid)
+                else
+                  @logger.warn("internal warning: unknown signal operation <#{sig_ope.inspect}>")
+                end
+
+                @process_wait_count_table[server_pid] = 0
+                server_pid = next_pid
+              else
+                @logger.warn("server continue (pid: #{server_pid})")
+              end
+            when :stat_get_and_reset
+              if (@sysop.send_signal(server_pid, SIGNAL_STAT_GET_AND_RESET)) then
+                @logger.info("stat get(reset: true) (pid: #{server_pid})")
+              else
+                @logger.error("failed to stat get(reset: true) (pid: #{server_pid})")
+              end
+            when :stat_get_no_reset
+              if (@sysop.send_signal(server_pid, SIGNAL_STAT_GET_NO_RESET)) then
+                @logger.info("stat get(reset: false) (pid: #{server_pid})")
+              else
+                @logger.error("failed to stat get(reset: false) (pid: #{server_pid})")
+              end
+            when :stat_stop
+              if (@sysop.send_signal(server_pid, SIGNAL_STAT_STOP)) then
+                @logger.info("stat stop (pid: #{server_pid})")
+              else
+                @logger.error("failed to stat stop (pid: #{server_pid})")
+              end
             else
-              @logger.warn("server continue (pid: #{server_pid})")
+              @logger.warn("internal warning: unknown signal operation <#{sig_ope.inspect}>")
             end
-          when :stat_get_and_reset
-            @logger.info("stat get(reset: true) (pid: #{server_pid})")
-            @sysop.send_signal(server_pid, SIGNAL_STAT_GET_AND_RESET) or @logger.error("failed to stat get(reset: true) (pid: #{server_pid})")
-          when :stat_get_no_reset
-            @logger.info("stat get(reset: false) (pid: #{server_pid})")
-            @sysop.send_signal(server_pid, SIGNAL_STAT_GET_NO_RESET) or @logger.error("failed to stat get(reset: false) (pid: #{server_pid})")
-          when :stat_stop
-            @logger.info("stat stop (pid: #{server_pid})")
-            @sysop.send_signal(server_pid, SIGNAL_STAT_STOP) or @logger.error("failed to stat stop (pid: #{server_pid})")
-          else
-            @logger.warn("internal warning: unknown signal operation <#{sig_ope.inspect}>")
           end
-        end
 
-        for pid in @process_wait_count_table.keys
-          if (@sysop.wait(pid, Process::WNOHANG)) then
-            @logger.info("server stop completed (pid: #{pid})")
-            @process_wait_count_table.delete(pid)
-          else
-            @process_wait_count_table[pid] += 1
-            if (@process_wait_count_table[pid] >= 2) then
-              @logger.warn("not stopped server process (pid: #{pid})")
+          for pid in @process_wait_count_table.keys
+            if (@sysop.wait(pid, Process::WNOHANG)) then
+              @logger.info("server stop completed (pid: #{pid})")
+              @process_wait_count_table.delete(pid)
+            else
+              @process_wait_count_table[pid] += 1
+              if (@process_wait_count_table[pid] >= 2) then
+                @logger.warn("not stopped server process (pid: #{pid})")
+              end
             end
           end
         end
-      end
 
-      if (server_pid) then
-        case (@stop_state)
-        when :graceful
-          @logger.info("server graceful stop (pid: #{server_pid})")
-          unless (server_stop_graceful(server_pid)) then
-            @logger.fatal('failed to stop daemon.')
-            return 1
-          end
-          unless (@sysop.wait(server_pid)) then
-            @logger.fatal('failed to stop daemon.')
-            return 1
-          end
-        when :forced
-          @logger.info("server forced stop (pid: #{server_pid})")
-          unless (server_stop_forced(server_pid)) then
-            @logger.fatal('failed to stop daemon.')
-            return 1
-          end
-          unless (@sysop.wait(server_pid)) then
-            @logger.fatal('failed to stop daemon.')
-            return 1
+        if (server_pid) then
+          case (@stop_state)
+          when :graceful
+            @logger.info("server graceful stop (pid: #{server_pid})")
+            unless (server_stop_graceful(server_pid)) then
+              @logger.fatal('failed to stop daemon.')
+              return 1
+            end
+            unless (@sysop.wait(server_pid)) then
+              @logger.fatal('failed to stop daemon.')
+              return 1
+            end
+          when :forced
+            @logger.info("server forced stop (pid: #{server_pid})")
+            unless (server_stop_forced(server_pid)) then
+              @logger.fatal('failed to stop daemon.')
+              return 1
+            end
+            unless (@sysop.wait(server_pid)) then
+              @logger.fatal('failed to stop daemon.')
+              return 1
+            end
+          else
+            @logger.warn("internal warning: unknown stop state <#{@stop_state.inspect}>")
           end
         else
-          @logger.error("internal error: unknown stop state <#{@stop_state.inspect}>")
-          return 1
+          @logger.warn('no server to stop.')
+        end
+      ensure
+        server_socket_local_address = server_socket.local_address # get local_address before close(2)
+        if (@sysop.close(server_socket)) then
+          @logger.info("close server socket: #{server_socket_local_address.inspect_sockaddr}") 
+        else
+          @logger.warn("failed to close server socket: #{server_socket_local_address.inspect_sockaddr}")
+        end
+        if (server_address.type == :unix) then
+          if (@sysop.unlink(server_address.path)) then
+            @logger.info("delete unix server socket: #{server_address}")
+          else
+            @logger.warn("failed to delete unix server socket: #{server_address}")
+          end
         end
-      else
-        @logger.warn('no server to stop.')
       end
 
       @logger.info('daemon stop.')

data/lib/riser/server.rb

@@ -2,7 +2,6 @@
 
 require 'io/wait'
 require 'socket'
-require 'uri'
 
 module Riser
   class TimeoutSizedQueue
@@ -164,123 +163,6 @@ module Riser
     end
   end
 
-  class SocketAddress
-    def initialize(type)
-      @type = type
-    end
-
-    attr_reader :type
-
-    def to_a
-      [ @type ]
-    end
-
-    def to_s
-      to_a.map{|s|
-        if (s.to_s.include? ':') then
-          "[#{s}]"
-        else
-          s
-        end
-      }.join(':')
-    end
-
-    def ==(other)
-      if (other.is_a? SocketAddress) then
-        self.to_a == other.to_a
-      else
-        false
-      end
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    def hash
-      to_a.hash ^ self.class.hash
-    end
-
-    def self.parse(config)
-      unsquare = proc{|s| s.sub(/\A \[/x, '').sub(/\] \z/x, '') }
-      case (config)
-      when String
-        case (config)
-        when /\A tcp:/x
-          uri = URI(config)
-          if (uri.host && uri.port) then
-            return TCPSocketAddress.new(unsquare.call(uri.host), uri.port)
-          end
-        when /\A unix:/x
-          uri = URI(config)
-          if (uri.path && ! uri.path.empty?) then
-            return UNIXSocketAddress.new(uri.path)
-          end
-        when %r"\A [A-Za-z]+:/"x
-          # unknown URI scheme
-        when /\A (\S+):(\d+) \z/x
-          host = $1
-          port = $2.to_i
-          return TCPSocketAddress.new(unsquare.call(host), port)
-        end
-      when Hash
-        if (type = config[:type] || config['type']) then
-          case (type.to_s)
-          when 'tcp'
-            host = config[:host] || config['host']
-            port = config[:port] || config['port']
-            if (host && (host.is_a? String) && port && (port.is_a? Integer)) then
-              return TCPSocketAddress.new(unsquare.call(host), port)
-            end
-          when 'unix'
-            path = config[:path] || config['path']
-            if (path && (path.is_a? String) && ! path.empty?) then
-              return UNIXSocketAddress.new(path)
-            end
-          end
-        end
-      end
-
-      return
-    end
-  end
-
-  class TCPSocketAddress < SocketAddress
-    def initialize(host, port)
-      super(:tcp)
-      @host = host
-      @port = port
-    end
-
-    attr_reader :host
-    attr_reader :port
-
-    def to_a
-      super << @host <<  @port
-    end
-
-    def open_server
-      TCPServer.new(@host, @port)
-    end
-  end
-
-  class UNIXSocketAddress < SocketAddress
-    def initialize(path)
-      super(:unix)
-      @path = path
-    end
-
-    attr_reader :path
-
-    def to_a
-      super << @path
-    end
-
-    def open_server
-      UNIXServer.new(@path)
-    end
-  end
-
   module ServerSignal
     SIGNAL_STOP_GRACEFUL      = :TERM
     SIGNAL_STOP_FORCED        = :INT
@@ -417,6 +299,9 @@ module Riser
     # _server_socket is a dummy argument to call like
     # SocketProcessDispatcher#start.
     def start(_server_socket=nil)
+      error_lock = Mutex.new
+      last_error = nil
+
       @preprocess.call
       begin
         queue = TimeoutSizedQueue.new(@thread_queue_size, name: @thread_queue_name)
@@ -424,13 +309,19 @@ module Riser
           thread_list = []
           @thread_num.times{|i|
             thread_list << Thread.new{
-              Thread.current[:number] = i
-              while (socket = queue.pop)
-                begin
-                  @dispatch.call(socket)
-                ensure
-                  socket.close unless socket.closed?
+              begin
+                Thread.current[:number] = i
+                while (socket = queue.pop)
+                  begin
+                    @dispatch.call(socket)
+                  ensure
+                    socket.close unless socket.closed?
+                  end
                 end
+              rescue
+                error_lock.synchronize{
+                  last_error = $!
+                }
               end
             }
           }
@@ -438,12 +329,14 @@ module Riser
           catch (:end_of_server) {
             while (true)
               begin
+                error_lock.synchronize{ last_error } and @stop_state = :forced
                 @stop_state and throw(:end_of_server)
                 apply_signal_stat(queue)
                 socket = @accept.call
               end until (socket)
 
               until (queue.push(socket, @thread_queue_polling_timeout_seconds))
+                error_lock.synchronize{ last_error } and @stop_state = :forced
                 if (@stop_state == :forced) then
                   socket.close
                   @accept_return.call
@@ -475,6 +368,12 @@ module Riser
         @postprocess.call
       end
 
+      error_lock.synchronize{
+        if (last_error) then
+          raise last_error
+        end
+      }
+
       nil
     end
   end
@@ -678,7 +577,11 @@ module Riser
 
       @process_dispatcher.accept{
         if (server_socket.wait_readable(@accept_polling_timeout_seconds) != nil) then
-          server_socket.accept
+          begin
+            server_socket.accept_nonblock
+          rescue IO::WaitReadable
+            nil                 # to avoid conflicting accept(2) at server restart overlap
+          end
         end
       }
       @process_dispatcher.accept_return(&NO_CALL)
@@ -834,7 +737,11 @@ module Riser
         @dispatcher.postprocess(&@postprocess)
         @dispatcher.accept{
           if (server_socket.wait_readable(@accept_polling_timeout_seconds) != nil) then
-            server_socket.accept
+            begin
+              server_socket.accept_nonblock
+            rescue IO::WaitReadable
+              nil               # to avoid conflicting accept(2) at server restart overlap
+            end
           end
         }
         @dispatcher.accept_return(&NO_CALL)

data/lib/riser/sockaddr.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+require 'socket'
+require 'uri'
+
+module Riser
+  class SocketAddress
+    def initialize(type, backlog=nil)
+      @type = type
+      @backlog = backlog
+    end
+
+    attr_reader :type
+    attr_reader :backlog
+
+    def to_address
+      [ @type ]
+    end
+
+    def to_option
+      option = {}
+      option[:backlog] = @backlog if @backlog
+      option
+    end
+
+    def ==(other)
+      if (other.is_a? SocketAddress) then
+        [ self.to_address, self.to_option ] == [ other.to_address, other.to_option ]
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      [ to_address, to_option ].hash ^ self.class.hash
+    end
+
+    def self.parse(config)
+      unsquare = proc{|s| s.sub(/\A \[/x, '').sub(/\] \z/x, '') }
+      case (config)
+      when String
+        case (config)
+        when /\A tcp:/x
+          uri = URI(config)
+          if (uri.host && uri.port) then
+            return TCPSocketAddress.new(unsquare.call(uri.host), uri.port)
+          end
+        when /\A unix:/x
+          uri = URI(config)
+          if (uri.path && ! uri.path.empty?) then
+            return UNIXSocketAddress.new(uri.path)
+          end
+        when %r"\A [A-Za-z]+:/"x
+          # unknown URI scheme
+        when /\A (\S+):(\d+) \z/x
+          host = $1
+          port = $2.to_i
+          return TCPSocketAddress.new(unsquare.call(host), port)
+        end
+      when Hash
+        if (type = config[:type] || config['type']) then
+          case (type.to_s)
+          when 'tcp'
+            host    = config[:host]    || config['host']
+            port    = config[:port]    || config['port']
+            backlog = config[:backlog] || config['backlog']
+            if ((host && (host.is_a? String) && ! host.empty?) &&
+                (port && (port.is_a? Integer)) &&
+                (backlog.nil? || (backlog.is_a? Integer)))
+            then
+              return TCPSocketAddress.new(unsquare.call(host), port, backlog)
+            end
+          when 'unix'
+            path    = config[:path]    || config['path']
+            backlog = config[:backlog] || config['backlog']
+            mode    = config[:mode]    || config['mode']
+            owner   = config[:owner]   || config['owner']
+            group   = config[:group]   || config['group']
+            if ((path && (path.is_a? String) && ! path.empty?) &&
+                (backlog.nil? || (backlog.is_a? Integer)) &&
+                (mode.nil? || (mode.is_a? Integer)) &&
+                (owner.nil? || (owner.is_a? Integer) || ((owner.is_a? String) && ! owner.empty?)) &&
+                (group.nil? || (group.is_a? Integer) || ((group.is_a? String) && ! group.empty?)))
+            then
+              return UNIXSocketAddress.new(path, backlog, mode, owner, group)
+            end
+          end
+        end
+      end
+
+      return
+    end
+  end
+
+  class TCPSocketAddress < SocketAddress
+    def initialize(host, port, backlog=nil)
+      super(:tcp, backlog)
+      @host = host
+      @port = port
+    end
+
+    attr_reader :host
+    attr_reader :port
+
+    def to_address
+      super << @host <<  @port
+    end
+
+    def to_s
+      if (@host.include? ':') then
+        "tcp://[#{host}]:#{port}"
+      else
+        "tcp://#{host}:#{port}"
+      end
+    end
+
+    def open_server
+      TCPServer.new(@host, @port)
+    end
+  end
+
+  class UNIXSocketAddress < SocketAddress
+    def initialize(path, backlog=nil, mode=nil, owner=nil, group=nil)
+      super(:unix, backlog)
+      @path = path
+      @mode = mode
+      @owner = owner
+      @group = group
+    end
+
+    attr_reader :path
+    attr_reader :mode
+    attr_reader :owner
+    attr_reader :group
+
+    def to_address
+      super << @path
+    end
+
+    def to_option
+      option = super
+      option[:mode] = @mode if @mode
+      option[:owner] = @owner if @owner
+      option[:group] = @group if @group
+      option
+    end
+
+    def to_s
+      "unix:#{@path}"
+    end
+
+    def open_server
+      UNIXServer.new(@path)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/lib/riser/version.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module Riser
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end
 
 # Local Variables:

data/lib/riser.rb

@@ -13,7 +13,7 @@ module Riser
   autoload :ResourceSet, 'riser/resource'
   autoload :RootProcess, 'riser/daemon'
   autoload :ServerSignal, 'riser/server'
-  autoload :SocketAddress, 'riser/server'
+  autoload :SocketAddress, 'riser/sockaddr'
   autoload :SocketServer, 'riser/server'
   autoload :StatusFile, 'riser/daemon'
   autoload :Stream, 'riser/stream'

data/riser.gemspec

@@ -10,8 +10,11 @@ Gem::Specification.new do |spec|
   spec.authors       = ["TOKI Yoshinori"]
   spec.email         = ["toki@freedom.ne.jp"]
 
-  spec.summary       = %q{Riser}
-  spec.description   = %q{Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process SERver.}
+  spec.summary       = %q{Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process SERver}
+  spec.description   = <<-'EOF'
+    Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process SERver.
+    This library is useful to make multi-thread/multi-process socket server and daemon. 
+  EOF
   spec.homepage      = "https://github.com/y10k/riser"
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - TOKI Yoshinori
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-06 00:00:00.000000000 Z
+date: 2019-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,8 +66,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process
-  SERver.
+description: "    Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process
+  SERver.\n    This library is useful to make multi-thread/multi-process socket server
+  and daemon. \n"
 email:
 - toki@freedom.ne.jp
 executables: []
@@ -98,6 +99,7 @@ files:
 - lib/riser/resource.rb
 - lib/riser/server.rb
 - lib/riser/services.rb
+- lib/riser/sockaddr.rb
 - lib/riser/stream.rb
 - lib/riser/temppath.rb
 - lib/riser/test.rb
@@ -125,5 +127,6 @@ requirements: []
 rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
-summary: Riser
+summary: Riser is a library of Ruby Infrastructure for cooperative multi-thread/multi-process
+  SERver
 test_files: []