zeus 0.4.5 → 0.4.6

data/lib/zeus/server.rb

@@ -2,22 +2,21 @@ require 'json'
 require 'socket'
 require 'forwardable'
 
+require 'zeus/server/stage'
+require 'zeus/server/acceptor'
+require 'zeus/server/file_monitor'
+require 'zeus/server/load_tracking'
+require 'zeus/server/client_handler'
+require 'zeus/server/command_runner'
+require 'zeus/server/process_tree_monitor'
+require 'zeus/server/acceptor_registration_monitor'
+
 module Zeus
   class Server
     extend Forwardable
 
-    autoload :Stage,                       'zeus/server/stage'
-    autoload :Acceptor,                    'zeus/server/acceptor'
-    autoload :FileMonitor,                 'zeus/server/file_monitor'
-    autoload :LoadTracking,                'zeus/server/load_tracking'
-    autoload :ForkedProcess,               'zeus/server/forked_process'
-    autoload :ClientHandler,               'zeus/server/client_handler'
-    autoload :CommandRunner,               'zeus/server/command_runner'
-    autoload :ProcessTreeMonitor,          'zeus/server/process_tree_monitor'
-    autoload :AcceptorRegistrationMonitor, 'zeus/server/acceptor_registration_monitor'
-
     def self.define!(&b)
-      @@definition = Zeus::DSL::Evaluator.new.instance_eval(&b)
+      @@definition = Zeus::Plan::Evaluator.new.instance_eval(&b)
     end
 
     def self.acceptors
@@ -44,16 +43,12 @@ module Zeus
     def run
       $0 = "zeus master"
       trap("TERM") { exit 0 }
-      trap("INT") {
-        puts "\n\x1b[31mExiting\x1b[0m"
-        exit 0
-      }
-
+      trap("INT") { puts "\n\x1b[31mExiting\x1b[0m" ; exit }
       LoadTracking.server = self
 
       @plan.run(true) # boot the actual app
       master = Process.pid
-      at_exit { @process_tree_monitor.kill_all_nodes if Process.pid == master }
+      at_exit { cleanup_all_children if Process.pid == master }
       monitors.each(&:close_child_socket)
 
       runloop!
@@ -61,6 +56,11 @@ module Zeus
       File.unlink(Zeus::SOCKET_NAME)
     end
 
+    def cleanup_all_children
+      @process_tree_monitor.kill_all_nodes
+      @file_monitor.kill_wrapper
+    end
+
     def add_extra_feature(full_expanded_path)
       $extra_loaded_features ||= []
       $extra_loaded_features << full_expanded_path

data/lib/zeus/server/acceptor.rb

@@ -1,7 +1,6 @@
 require 'json'
 require 'socket'
 
-# See Zeus::Server::ClientHandler for relevant documentation
 module Zeus
   class Server
     class Acceptor
@@ -17,8 +16,7 @@ module Zeus
       def run
         register_with_client_handler(Process.pid)
         Zeus.ui.info("starting #{process_type} `#{@name}`")
-
-        thread_with_backtrace_on_error { runloop! }
+        Zeus.thread_with_backtrace_on_error { runloop! }
       end
 
       private
@@ -30,6 +28,7 @@ module Zeus
       def register_with_client_handler(pid)
         @s_client_handler, @s_acceptor = UNIXSocket.pair
         @s_acceptor.puts registration_data(pid)
+        at_exit { @s_client_handler.close ; @s_acceptor.close }
         @server.__CHILD__register_acceptor(@s_client_handler)
       end
 
@@ -39,36 +38,20 @@ module Zeus
 
       def accept_connection
         terminal = @s_acceptor.recv_io # blocking
+        exit_status_socket = @s_acceptor.recv_io
         arguments = JSON.parse(@s_acceptor.readline.chomp)
 
-        [terminal, arguments]
+        [terminal, exit_status_socket, arguments]
       end
 
       def process_type
         "acceptor"
       end
 
-      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
-      end
-
-      def thread_with_backtrace_on_error(&b)
-        Thread.new {
-          begin
-            b.call
-          rescue => e
-            print_error($stdout, e)
-          end
-        }
-      end
-
       def runloop!
         loop do
-          terminal, arguments = accept_connection # blocking
-          command_runner.run(terminal, arguments)
+          terminal, exit_status_socket, arguments = accept_connection # blocking
+          command_runner.run(terminal, exit_status_socket, arguments)
         end
       end
 
@@ -85,7 +68,7 @@ module Zeus
             terminal = @s_acceptor.recv_io
             _ = @s_acceptor.readline
             @s_acceptor << NOT_A_PID << "\n"
-            print_error(terminal, @error)
+            ErrorPrinter.new(@error).write_to(terminal)
             terminal.close
           end
         end

data/lib/zeus/server/acceptor_registration_monitor.rb

@@ -5,8 +5,8 @@ module Zeus
       def datasource          ; @sock ; end
       def on_datasource_event ; handle_message ; end
       # @__CHILD__sock is not closed here, as it's used by the master to respond
-      # for unbooted acceptors
-      def close_child_socket  ; end 
+      # on behalf of unbooted acceptors
+      def close_child_socket  ; end
       def close_parent_socket ; @sock.close ; end
 
       def initialize
@@ -26,7 +26,6 @@ module Zeus
         case type
         when 'wait' ; handle_wait(io, data)
         when 'registration' ; handle_registration(io, data)
-        when 'deregistration' ; handle_deregistration(io, data)
         else raise "invalid message"
         end
       end
@@ -37,11 +36,6 @@ module Zeus
         @pings[command] << io
       end
 
-      def handle_deregistration(io, data)
-        pid = data['pid'].to_i
-        @acceptors.reject!{|acc|acc.pid == pid}
-      end
-
       def handle_registration(io, data)
         pid         = data['pid'].to_i
         commands    = data['commands']
@@ -62,7 +56,6 @@ module Zeus
         end
       end
 
-
       module ChildProcessApi
 
         def __CHILD__find_acceptor_for_command(command)
@@ -78,6 +71,5 @@ module Zeus
       end ; include ChildProcessApi
 
     end
-
   end
 end

data/lib/zeus/server/client_handler.rb

@@ -1,28 +1,9 @@
 require 'socket'
 require 'json'
 
+# This class is a little confusing. See the docs/ directory for guidance.
 module Zeus
   class Server
-    # The model here is kind of convoluted, so here's an explanation of what's
-    # happening with all these sockets:
-    #
-    # #### Acceptor Registration
-    # 1. ClientHandler creates a socketpair for Acceptor registration (S_REG)
-    # 2. When an acceptor is spawned, it:
-    #   1. Creates a new socketpair for communication with clienthandler (S_ACC)
-    #   2. Sends one side of S_ACC over S_REG to clienthandler.
-    #   3. Sends a JSON-encoded hash of `pid`, `commands`, and `description`. over S_REG.
-    # 3. ClientHandler received first the IO and then the JSON hash, and stores them for later reference.
-    #
-    # #### Running a command
-    # 1. ClientHandler has a UNIXServer (SVR) listening.
-    # 2. ClientHandler has a socketpair with the acceptor referenced by the command (see Registration) (S_ACC)
-    # 3. When clienthandler received a connection (S_CLI) on SVR:
-    #   1. ClientHandler sends S_CLI over S_ACC, so the acceptor can communicate with the server's client.
-    #   2. ClientHandler sends a JSON-encoded array of `arguments` over S_ACC
-    #   3. Acceptor sends the newly-forked worker PID over S_ACC to clienthandler.
-    #   4. ClientHandler forwards the pid to the client over S_CLI.
-    #
     class ClientHandler
       def datasource          ; @listener ; end
       def on_datasource_event ; handle_server_connection ; end
@@ -43,20 +24,15 @@ module Zeus
 
       private
 
-      #  client clienthandler acceptor
-      # 1  ---------->                | {command: String, arguments: [String]}
-      # 2  ---------->                | Terminal IO
-      # 3            ----------->     | Terminal IO
-      # 4            ----------->     | Arguments (json array)
-      # 5            <-----------     | pid
-      # 6  <---------                 | pid
+      # See docs/client_server_handshake.md for details
       def handle_server_connection
         s_client = @listener.accept
 
-        data = JSON.parse(s_client.readline.chomp) # step 1
+        data = JSON.parse(s_client.readline.chomp)
         command, arguments = data.values_at('command', 'arguments')
 
-        client_terminal = s_client.recv_io # step 2
+        client_terminal = s_client.recv_io
+        exit_status_socket = s_client.recv_io
 
         Thread.new {
           # This is a little ugly. Gist: Try to handshake the client to the acceptor.
@@ -64,7 +40,7 @@ module Zeus
           # REATTEMPT_HANDSHAKE. We catch that exit code and try once more.
           begin
             loop do
-              pid = fork { handshake_client_to_acceptor(s_client, command, arguments, client_terminal) ; exit }
+              pid = fork { handshake_client_to_acceptor(s_client, command, arguments, client_terminal, exit_status_socket) ; exit }
               Process.wait(pid)
               break if $?.exitstatus != REATTEMPT_HANDSHAKE
             end
@@ -75,22 +51,22 @@ module Zeus
         }
       end
 
-      def handshake_client_to_acceptor(s_client, command, arguments, client_terminal)
+      def handshake_client_to_acceptor(s_client, command, arguments, client_terminal, exit_status_socket)
         unless @acceptor_commands.include?(command.to_s)
           msg = "no such command `#{command}`."
           return exit_with_message(s_client, client_terminal, msg)
         end
 
-        unless acceptor = send_io_to_acceptor(client_terminal, command) # step 3
+        unless acceptor = send_io_to_acceptor(client_terminal, exit_status_socket, command)
           wait_for_acceptor(s_client, client_terminal, command)
           exit REATTEMPT_HANDSHAKE
         end
 
         Zeus.ui.info "accepting connection for #{command}"
 
-        acceptor.socket.puts arguments.to_json # step 4
-        pid = acceptor.socket.readline.chomp.to_i # step 5
-        s_client.puts pid # step 6
+        acceptor.socket.puts arguments.to_json
+        pid = acceptor.socket.readline.chomp.to_i
+        s_client.puts pid
         s_client.close
       end
 
@@ -113,17 +89,18 @@ module Zeus
         s.readline # wait until acceptor is booted
       end
 
-      def send_io_to_acceptor(io, command)
+      def send_io_to_acceptor(io, io2, command)
         return false unless acceptor = @server.__CHILD__find_acceptor_for_command(command)
         return false unless usock = UNIXSocket.for_fd(acceptor.socket.fileno)
         usock.send_io(io)
+        usock.send_io(io2)
         io.close
+        io2.close
         return acceptor
       rescue Errno::EPIPE
         return false
       end
 
-
     end
   end
 end

data/lib/zeus/server/command_runner.rb

@@ -8,36 +8,56 @@ module Zeus
         @s_acceptor = s_acceptor
       end
 
-      def run(terminal, arguments)
-        child = fork { _run(terminal, arguments) }
+      def run(terminal, exit_status_socket, arguments)
+        child = fork { _run(terminal, exit_status_socket, arguments) }
         terminal.close
+        exit_status_socket.close
         Process.detach(child)
         child
       end
 
       private
 
-      def _run(terminal, arguments)
+      def _run(terminal, exit_status_socket, arguments)
         $0 = "zeus runner: #{@name}"
+        @exit_status_socket = exit_status_socket
+        @terminal = terminal
         Process.setsid
         reconnect_activerecord!
         @s_acceptor << $$ << "\n"
-        $stdin.reopen(terminal)
-        $stdout.reopen(terminal)
-        $stderr.reopen(terminal)
+        reopen_streams(terminal, terminal, terminal)
         ARGV.replace(arguments)
 
+        return_process_exit_status
+
+        run_action
+      end
+
+      def return_process_exit_status
+        at_exit do
+          if $!.nil? || $!.is_a?(SystemExit) && $!.success?
+            @exit_status_socket.puts(0)
+          else
+            code = $!.is_a?(SystemExit) ? $!.status : 1
+            @exit_status_socket.puts(code)
+          end
+
+          @exit_status_socket.close
+          @terminal.close
+        end
+      end
+
+      def run_action
         @action.call
-      ensure
-        # TODO this is a whole lot of voodoo that I don't really understand.
-        # I need to figure out how best to make the process disconenct cleanly.
-        dnw, dnr = File.open("/dev/null", "w+"), File.open("/dev/null", "r+")
-        $stderr.reopen(dnr)
-        $stdout.reopen(dnr)
-        terminal.close
-        $stdin.reopen(dnw)
-        Process.kill(9, $$)
-        exit 0
+      rescue StandardError => error
+        ErrorPrinter.new(error).write_to($stderr)
+        raise
+      end
+
+      def reopen_streams(i, o, e)
+        $stdin.reopen(i)
+        $stdout.reopen(o)
+        $stderr.reopen(e)
       end
 
       def reconnect_activerecord!

data/lib/zeus/server/file_monitor.rb

@@ -1,7 +1,8 @@
+require 'zeus/server/file_monitor/fsevent'
+
 module Zeus
   class Server
     module FileMonitor
-      autoload :FSEvent, 'zeus/server/file_monitor/fsevent'
     end
   end
 end

data/lib/zeus/server/file_monitor/fsevent.rb

@@ -14,7 +14,7 @@ module Zeus
 
         def initialize(&change_callback)
           @change_callback = change_callback
-          @io_in, @io_out, _ = open_wrapper
+          @io_in, @io_out, @wrapper_thread = open_wrapper
           @givenpath_to_realpath = {}
           @realpath_to_givenpath = {}
           @buffer = ""
@@ -38,6 +38,11 @@ module Zeus
           true
         end
 
+        def kill_wrapper
+          Process.kill(9, @wrapper_thread.pid)
+        rescue Errno::ESRCH # already dead. SIGINT to master causes this often.
+        end
+
         private
 
         def realpath(file)

data/lib/zeus/server/stage.rb

@@ -1,31 +1,63 @@
+require 'zeus/server/stage/error_state'
+require 'zeus/server/stage/feature_notifier'
+
 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 < ForkedProcess
-      attr_accessor :stages, :actions
+    class Stage
+
+      attr_accessor :name, :stages, :actions
+      def initialize(server)
+        @server = server
+      end
 
       def descendent_acceptors
         @stages.map(&:descendent_acceptors).flatten
       end
 
+      def run(close_parent_sockets = false)
+        @pid = fork {
+          setup_fork(close_parent_sockets)
+          run_actions
+          feature_notifier.notify_new_features
+          start_child_stages
+          handle_child_exit_loop!
+        }
+      end
 
-      def after_setup
-        begin
-          @actions.each(&:call)
-        rescue => e
-          handle_load_error(e)
-        end
+      private
+
+      def setup_fork(close_parent_sockets)
+        $0 = "zeus #{process_type}: #{@name}"
+        @server.__CHILD__close_parent_sockets if close_parent_sockets
+        notify_started
+        trap("INT") { exit }
+        trap("TERM") { notify_terminated ; exit }
+        ActiveRecord::Base.clear_all_connections! rescue nil
+      end
+
+      def feature_notifier
+        FeatureNotifier.new(@server, @name)
       end
 
-      def after_notify
+      def start_child_stages
         @pids = {}
         @stages.each do |stage|
           @pids[stage.run] = stage
         end
       end
 
-      def runloop!
+      def run_actions
+        begin
+          @actions.each(&:call)
+        rescue => e
+          extend(ErrorState)
+          handle_load_error(e)
+        end
+      end
+
+      def handle_child_exit_loop!
         loop do
           begin
             pid = Process.wait
@@ -37,41 +69,18 @@ module Zeus
         end
       end
 
-      private
-
-      def register_acceptors_as_errors(e)
-        descendent_acceptors.each do |acc|
-          acc = acc.extend(Acceptor::ErrorState)
-          acc.error = e
-          acc.run
-        end
-      end
-
-      def process_type
-        "spawner"
+      def notify_started
+        @server.__CHILD__stage_starting_with_pid(@name, Process.pid)
+        Zeus.ui.info("starting #{process_type} `#{@name}`")
       end
 
-      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
+      def notify_terminated
+        Zeus.ui.info("killing #{process_type} `#{@name}`")
       end
 
-      def handle_load_error(e)
-        errored_file = full_path_of_file_from_error(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) }
-
-        # we do not need to do anything. We wait, until a dependency changes.
-        # At that point, we get killed and restarted.
-        sleep
+      def process_type
+        "spawner"
       end
 
     end