zeus 0.2.5 → 0.2.6

data/lib/zeus/server.rb

@@ -8,7 +8,9 @@ module Zeus
     autoload :Acceptor,                    'zeus/server/acceptor'
     autoload :FileMonitor,                 'zeus/server/file_monitor'
     autoload :ProcessTree,                 'zeus/server/process_tree'
+    autoload :ForkedProcess,               'zeus/server/forked_process'
     autoload :ClientHandler,               'zeus/server/client_handler'
+    autoload :AcceptorErrorState,          'zeus/server/acceptor_error_state'
     autoload :ProcessTreeMonitor,          'zeus/server/process_tree_monitor'
     autoload :AcceptorRegistrationMonitor, 'zeus/server/acceptor_registration_monitor'
 

data/lib/zeus/server/acceptor.rb

@@ -4,18 +4,45 @@ require 'socket'
 # See Zeus::Server::ClientHandler for relevant documentation
 module Zeus
   class Server
-    class Acceptor
+    class Acceptor < ForkedProcess
+      attr_accessor :aliases, :description, :action
 
-      attr_accessor :name, :aliases, :description, :action
-      def initialize(server)
-        @server = server
+      def descendent_acceptors
+        self
+      end
+
+      def before_setup
+        register_with_client_handler(Process.pid)
+      end
+
+      def runloop!
+        loop do
+          prefork_action!
+          terminal, arguments = accept_connection # blocking
+          child = fork { __RUNNER__run(terminal, arguments) }
+          terminal.close
+
+          Process.detach(child)
+        end
+      end
+
+      def __RUNNER__run(terminal, arguments)
+        $0 = "zeus runner: #{@name}"
+        postfork_action!
+        @s_acceptor << $$ << "\n"
+        $stdin.reopen(terminal)
+        $stdout.reopen(terminal)
+        $stderr.reopen(terminal)
+        ARGV.replace(arguments)
+
+        @action.call
       end
 
+      private
+
       def register_with_client_handler(pid)
         @s_client_handler, @s_acceptor = UNIXSocket.pair
-
         @s_acceptor.puts registration_data(pid)
-
         @server.__CHILD__register_acceptor(@s_client_handler)
       end
 
@@ -23,91 +50,28 @@ module Zeus
         {type: 'registration', pid: pid, commands: [name, *aliases], description: description}.to_json
       end
 
-      def descendent_acceptors
-        self
-      end
+      def accept_connection
+        terminal = @s_acceptor.recv_io # blocking
+        arguments = JSON.parse(@s_acceptor.readline.chomp)
 
-      def print_error(io, error)
-        io.puts "#{error.backtrace[0]}: #{error.message} (#{error.class})"
-        error.backtrace[1..-1].each do |line|
-          io.puts "\tfrom #{line}"
-        end
+        [terminal, arguments]
       end
 
-      def run_as_error(e)
-        register_with_client_handler(Process.pid)
-        Zeus.ui.as_zeus "starting error-state acceptor `#{@name}`"
-
-        Thread.new do
-          loop do
-            terminal = @s_acceptor.recv_io
-            _ = @s_acceptor.readline
-            @s_acceptor << 0 << "\n"
-            print_error(terminal, e)
-            terminal.close
-          end
-        end
+      def process_type
+        "acceptor"
       end
 
-      def run
-        pid = fork {
-          $0 = "zeus acceptor: #{@name}"
-          pid = Process.pid
-
-          register_with_client_handler(pid)
-
-          @server.__CHILD__pid_has_ppid(pid, Process.ppid)
-
-          Zeus.ui.as_zeus "starting acceptor `#{@name}`"
-          trap("INT") {
-            Zeus.ui.as_zeus "killing acceptor `#{@name}`"
-            exit 0
-          }
-
-          # Apparently threads don't continue in forks.
-          Thread.new {
-            $LOADED_FEATURES.each do |f|
-              @server.__CHILD__pid_has_feature(pid, f)
-            end
-          }
-
-          loop do
-            prefork_action!
-            terminal = @s_acceptor.recv_io
-            arguments = JSON.parse(@s_acceptor.readline.chomp)
-            child = fork do
-              $0 = "zeus runner: #{@name}"
-              postfork_action!
-              @s_acceptor << $$ << "\n"
-              $stdin.reopen(terminal)
-              $stdout.reopen(terminal)
-              $stderr.reopen(terminal)
-              ARGV.replace(arguments)
-
-              @action.call
-            end
-            Process.detach(child)
-            terminal.close
-          end
-
-        }
-        currpid = Process.pid
-        at_exit {
-          if Process.pid == currpid
-            Process.kill(9, pid) rescue nil
-          end
-        }
-        pid
-      end
 
+      # these two methods should be part of the configuration DSL.
+      # They're here for now, but I want them out.
       def prefork_action! # TODO : refactor
-        ActiveRecord::Base.clear_all_connections!
+        ActiveRecord::Base.clear_all_connections! rescue nil
       end
 
       def postfork_action! # TODO :refactor
-        ActiveRecord::Base.establish_connection
-        ActiveSupport::DescendantsTracker.clear
-        ActiveSupport::Dependencies.clear
+        ActiveRecord::Base.establish_connection   rescue nil
+        ActiveSupport::DescendantsTracker.clear   rescue nil
+        ActiveSupport::Dependencies.clear         rescue nil
       end
 
     end

data/lib/zeus/server/acceptor_error_state.rb

@@ -0,0 +1,35 @@
+require 'json'
+require 'socket'
+
+# See Zeus::Server::ClientHandler for relevant documentation
+module Zeus
+  class Server
+    module ErrorStateAcceptor
+      attr_accessor :error
+
+      def print_error(io, error = @error)
+        io.puts "#{error.backtrace[0]}: #{error.message} (#{error.class})"
+        error.backtrace[1..-1].each do |line|
+          io.puts "\tfrom #{line}"
+        end
+      end
+
+      def run
+        register_with_client_handler(Process.pid)
+        Zeus.ui.as_zeus "starting error-state acceptor `#{@name}`"
+
+        Thread.new do
+          loop do
+            terminal = @s_acceptor.recv_io
+            _ = @s_acceptor.readline
+            @s_acceptor << 0 << "\n"
+            print_error(terminal)
+            terminal.close
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/zeus/server/acceptor_registration_monitor.rb

@@ -4,7 +4,9 @@ module Zeus
 
       def datasource          ; @sock ; end
       def on_datasource_event ; handle_message ; end
-      def close_child_socket  ; @__CHILD__sock.close ; end
+      # @__CHILD__sock is not closed here, as it's used by the master to respond
+      # for unbooted acceptors
+      def close_child_socket  ; end 
       def close_parent_socket ; @sock.close ; end
 
       def initialize

data/lib/zeus/server/forked_process.rb

@@ -0,0 +1,71 @@
+module Zeus
+  class Server
+    class ForkedProcess
+      HasNoChildren = Class.new(Exception)
+
+      attr_accessor :name
+      attr_reader :pid
+      def initialize(server)
+        @server = server
+      end
+
+      def notify_feature(feature)
+        @server.__CHILD__pid_has_feature(Process.pid, feature)
+      end
+
+      def descendent_acceptors
+        raise NotImplementedError
+      end
+
+      def process_type
+        raise "NotImplementedError"
+      end
+
+      def setup_forked_process(close_parent_sockets)
+        @server.__CHILD__close_parent_sockets if close_parent_sockets
+        @server.__CHILD__pid_has_ppid(Process.pid, Process.ppid)
+
+        $0 = "zeus #{process_type}: #{@name}"
+
+        Zeus.ui.as_zeus("starting #{process_type} `#{@name}`")
+        trap("INT") {
+          Zeus.ui.as_zeus("killing #{process_type} `#{@name}`")
+          exit 0
+        }
+
+        Thread.new {
+          $LOADED_FEATURES.each { |f| notify_feature(f) }
+        }
+      end
+
+      def kill_pid_on_exit(pid)
+        currpid = Process.pid
+        at_exit { Process.kill(9, pid) if Process.pid == currpid rescue nil }
+      end
+
+      def runloop!
+        raise NotImplementedError
+      end
+
+      def before_setup
+      end
+
+      def after_setup
+      end
+
+      def run(close_parent_sockets = false)
+        @pid = fork {
+          before_setup
+          setup_forked_process(close_parent_sockets)
+          after_setup
+          runloop!
+        }
+        kill_pid_on_exit(@pid)
+        @pid
+      end
+
+    end
+
+  end
+end
+

data/lib/zeus/server/stage.rb

@@ -2,40 +2,68 @@ module Zeus
   class Server
     # NONE of the code in the module is run in the master process,
     # so every communication to the master must be done with IPC.
-    class Stage
-      HasNoChildren = Class.new(Exception)
+    class Stage < ForkedProcess
+      attr_accessor :stages, :actions
 
-      attr_accessor :name, :stages, :actions
-      attr_reader :pid
-      def initialize(server)
-        @server = server
+      def descendent_acceptors
+        @stages.map(&:descendent_acceptors).flatten
       end
 
-      def notify_feature(feature)
-        @server.__CHILD__pid_has_feature(Process.pid, feature)
+
+      def after_setup
+        begin
+          @actions.each(&:call)
+        rescue => e
+          handle_load_error(e)
+        end
+
+        @pids = {}
+        @stages.each do |stage|
+          @pids[stage.run] = stage
+        end
       end
 
-      def descendent_acceptors
-        @stages.map(&:descendent_acceptors).flatten
+      def runloop!
+        loop do
+          begin
+            pid = Process.wait
+          rescue Errno::ECHILD
+            raise HasNoChildren.new("Stage `#{@name}` - All terminal nodes must be acceptors")
+          end
+          stage = @pids[pid]
+          @pids[stage.run] = stage
+        end
       end
 
+
+      private
+
       def register_acceptors_as_errors(e)
         descendent_acceptors.each do |acc|
-          acc.run_as_error(e)
+          acc = acc.extend(AcceptorErrorState)
+          acc.error = e
+          acc.run
         end
       end
 
+      def process_type
+        "spawner"
+      end
 
-      def handle_load_error(e)
+      def full_path_of_file_from_error(e)
         errored_file = e.backtrace[0].scan(/(.+?):\d+:in/)[0][0]
 
         # handle relative paths
         unless errored_file =~ /^\//
           errored_file = File.expand_path(errored_file, Dir.pwd)
         end
+      end
+
+      def handle_load_error(e)
+        errored_file = full_path_of_file_from_error(e)
 
-        register_acceptors_as_errors(e)
         # register all the decendent acceptors as stubs with errors
+        register_acceptors_as_errors(e)
 
         notify_feature(errored_file)
         $LOADED_FEATURES.each { |f| notify_feature(f) }
@@ -45,51 +73,6 @@ module Zeus
         sleep
       end
 
-      def run(close_parent_sockets = false)
-        @pid = fork {
-          # This is only passed to the top-level stage, from Server#run, not sub-stages.
-          @server.__CHILD__close_parent_sockets if close_parent_sockets
-
-          $0 = "zeus spawner: #{@name}"
-          @server.__CHILD__pid_has_ppid(Process.pid, Process.ppid)
-
-          Zeus.ui.as_zeus("starting spawner `#{@name}`")
-          trap("INT") {
-            Zeus.ui.as_zeus("killing spawner `#{@name}`")
-            exit 0
-          }
-
-          begin
-            @actions.each(&:call)
-          rescue => e
-            handle_load_error(e)
-          end
-
-          pids = {}
-          @stages.each do |stage|
-            pids[stage.run] = stage
-          end
-
-          Thread.new {
-            $LOADED_FEATURES.each { |f| notify_feature(f) }
-          }
-
-          loop do
-            begin
-              pid = Process.wait
-            rescue Errno::ECHILD
-              raise HasNoChildren.new("Stage `#{@name}` - All terminal nodes must be acceptors")
-            end
-            stage = pids[pid]
-            pids[stage.run] = stage
-          end
-        }
-        currpid = Process.pid
-        at_exit { Process.kill(9, @pid) if Process.pid == currpid rescue nil }
-        @pid
-      end
-
     end
-
   end
 end

data/lib/zeus/version.rb

@@ -1,3 +1,3 @@
 module Zeus
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
   prerelease: 
 platform: ruby
 authors:
@@ -35,10 +35,12 @@ files:
 - lib/zeus/dsl.rb
 - lib/zeus/server.rb
 - lib/zeus/server/acceptor.rb
+- lib/zeus/server/acceptor_error_state.rb
 - lib/zeus/server/acceptor_registration_monitor.rb
 - lib/zeus/server/client_handler.rb
 - lib/zeus/server/file_monitor.rb
 - lib/zeus/server/file_monitor/fsevent.rb
+- lib/zeus/server/forked_process.rb
 - lib/zeus/server/process_tree.rb
 - lib/zeus/server/process_tree_monitor.rb
 - lib/zeus/server/stage.rb