zeus 0.2.4 → 0.2.5

data/ext/fsevents-wrapper/main.m

@@ -123,11 +123,9 @@ void configureTimerAndRun()
 
 int main(int argc, const char * argv[])
 {
-    @autoreleasepool {
-        _watchedFiles = CFArrayCreateMutable(NULL, 0, NULL);
-        _fileIsWatched = [[NSMutableDictionary alloc] initWithCapacity:500];
+    _watchedFiles = CFArrayCreateMutable(NULL, 0, NULL);
+    _fileIsWatched = [[NSMutableDictionary alloc] initWithCapacity:500];
         
-        configureTimerAndRun();
-    }
+    configureTimerAndRun();
     return 0;
 }

data/lib/zeus/server.rb

@@ -7,6 +7,7 @@ module Zeus
     autoload :Stage,                       'zeus/server/stage'
     autoload :Acceptor,                    'zeus/server/acceptor'
     autoload :FileMonitor,                 'zeus/server/file_monitor'
+    autoload :ProcessTree,                 'zeus/server/process_tree'
     autoload :ClientHandler,               'zeus/server/client_handler'
     autoload :ProcessTreeMonitor,          'zeus/server/process_tree_monitor'
     autoload :AcceptorRegistrationMonitor, 'zeus/server/acceptor_registration_monitor'
@@ -19,15 +20,13 @@ module Zeus
       @@definition.acceptors
     end
 
-    attr_reader :client_handler, :acceptor_registration_monitor
     def initialize
       @file_monitor                  = FileMonitor::FSEvent.new(&method(:dependency_did_change))
       @acceptor_registration_monitor = AcceptorRegistrationMonitor.new
-      @process_tree_monitor          = ProcessTreeMonitor.new
+      @process_tree_monitor          = ProcessTreeMonitor.new(@file_monitor)
       acceptor_commands = self.class.acceptors.map(&:commands).flatten
-      @client_handler                = ClientHandler.new(acceptor_commands, acceptor_registration_monitor)
+      @client_handler                = ClientHandler.new(acceptor_commands, self)
 
-      # TODO: deprecate Zeus::Server.define! maybe. We can do that better...
       @plan = @@definition.to_domain_object(self)
     end
 
@@ -35,85 +34,51 @@ module Zeus
       @process_tree_monitor.kill_nodes_with_feature(file)
     end
 
-    PID_TYPE = "P"
-    def w_pid line
-      @w_msg.send(PID_TYPE + line, 0)
-    rescue Errno::ENOBUFS
-      sleep 0.2
-      retry
-    end
-
-    FEATURE_TYPE = "F"
-    def w_feature line
-      @w_msg.send(FEATURE_TYPE + line, 0)
-    rescue Errno::ENOBUFS
-      sleep 0.2
-      retry
+    def monitors
+      [@file_monitor, @process_tree_monitor, @acceptor_registration_monitor, @client_handler]
     end
 
     def run
       $0 = "zeus master"
       trap("INT") { exit 0 }
 
-      @r_msg, @w_msg = Socket.pair(:UNIX, :DGRAM)
-
-      # boot the actual app
-      @plan.run
-      @w_msg.close
+      @plan.run(true) # boot the actual app
+      monitors.each(&:close_child_socket)
 
       loop do
-        monitors = [@file_monitor, @acceptor_registration_monitor, @client_handler]
-        # TODO: Make @r_msg a Monitor instead. All that logic should be its own thing.
-        datasources = [@r_msg, *monitors.map(&:datasource)]
-
-        ready, _, _ = IO.select(datasources, [], [], 1)
+        ready, = IO.select(monitors.map(&:datasource), [], [], 1)
         next unless ready
         monitors.each do |m|
           m.on_datasource_event if ready.include?(m.datasource)
         end
-        handle_messages if ready.include?(@r_msg)
       end
-
     ensure
       File.unlink(Zeus::SOCKET_NAME)
     end
 
-    def handle_messages
-      50.times {
-        handle_message
-      }
-    rescue Errno::EAGAIN
-    end
+    module ChildProcessApi
 
-    def handle_message
-      data = @r_msg.recv_nonblock(1024)
-      case data[0]
-      when FEATURE_TYPE
-        handle_feature_message(data[1..-1])
-      when PID_TYPE
-        handle_pid_message(data[1..-1])
-      else
-        raise "Unrecognized message"
+      def __CHILD__close_parent_sockets
+        monitors.each(&:close_parent_socket)
       end
-    end
 
-    def handle_pid_message(data)
-      data =~ /(\d+):(\d+)/
-        pid, ppid = $1.to_i, $2.to_i
-      @process_tree_monitor.process_has_parent(pid, ppid)
-    end
+      def __CHILD__pid_has_ppid(pid, ppid)
+        @process_tree_monitor.__CHILD__send_pid("#{pid}:#{Process.ppid}")
+      end
 
-    def handle_feature_message(data)
-      data =~ /(\d+):(.*)/
-        pid, file = $1.to_i, $2
-      @process_tree_monitor.process_has_feature(pid, file)
-      @file_monitor.watch(file)
-    end
+      def __CHILD__pid_has_feature(pid, feature)
+        @process_tree_monitor.__CHILD__send_feature("#{pid}:#{feature}")
+      end
 
-    def self.pid_has_file(pid, file)
-      @@files[file] ||= []
-      @@files[file] << pid
-    end
+      def __CHILD__register_acceptor(io)
+        @acceptor_registration_monitor.__CHILD__register_acceptor(io)
+      end
+
+      def __CHILD__find_acceptor_for_command(command)
+        @acceptor_registration_monitor.__CHILD__find_acceptor_for_command(command)
+      end
+
+    end ; include ChildProcessApi
 
   end
 end

data/lib/zeus/server/acceptor.rb

@@ -9,8 +9,6 @@ module Zeus
       attr_accessor :name, :aliases, :description, :action
       def initialize(server)
         @server = server
-        @client_handler = server.client_handler
-        @registration_monitor = server.acceptor_registration_monitor
       end
 
       def register_with_client_handler(pid)
@@ -18,7 +16,7 @@ module Zeus
 
         @s_acceptor.puts registration_data(pid)
 
-        @registration_monitor.acceptor_registration_socket.send_io(@s_client_handler)
+        @server.__CHILD__register_acceptor(@s_client_handler)
       end
 
       def registration_data(pid)
@@ -58,7 +56,7 @@ module Zeus
 
           register_with_client_handler(pid)
 
-          @server.w_pid "#{pid}:#{Process.ppid}"
+          @server.__CHILD__pid_has_ppid(pid, Process.ppid)
 
           Zeus.ui.as_zeus "starting acceptor `#{@name}`"
           trap("INT") {
@@ -69,7 +67,7 @@ module Zeus
           # Apparently threads don't continue in forks.
           Thread.new {
             $LOADED_FEATURES.each do |f|
-              @server.w_feature "#{pid}:#{f}"
+              @server.__CHILD__pid_has_feature(pid, f)
             end
           }
 

data/lib/zeus/server/acceptor_registration_monitor.rb

@@ -2,11 +2,13 @@ module Zeus
   class Server
     class AcceptorRegistrationMonitor
 
-      def datasource          ; @reg_monitor ; end
+      def datasource          ; @sock ; end
       def on_datasource_event ; handle_message ; end
+      def close_child_socket  ; @__CHILD__sock.close ; end
+      def close_parent_socket ; @sock.close ; end
 
       def initialize
-        @reg_monitor, @reg_acceptor = UNIXSocket.pair
+        @sock, @__CHILD__sock = UNIXSocket.pair
         @acceptors = []
         @pings = {}
       end
@@ -14,7 +16,7 @@ module Zeus
       AcceptorStub = Struct.new(:pid, :socket, :commands, :description)
 
       def handle_message
-        io = @reg_monitor.recv_io
+        io = @sock.recv_io
 
         data = JSON.parse(io.readline.chomp)
         type = data['type']
@@ -58,15 +60,20 @@ module Zeus
         end
       end
 
-      def find_acceptor_for_command(command)
-        @acceptors.detect { |acceptor|
-          acceptor.commands.include?(command)
-        }
-      end
 
-      def acceptor_registration_socket
-        @reg_acceptor
-      end
+      module ChildProcessApi
+
+        def __CHILD__find_acceptor_for_command(command)
+          @acceptors.detect { |acceptor|
+            acceptor.commands.include?(command)
+          }
+        end
+
+        def __CHILD__register_acceptor(io)
+          @__CHILD__sock.send_io(io)
+        end
+
+      end ; include ChildProcessApi
 
     end
 

data/lib/zeus/server/client_handler.rb

@@ -24,21 +24,23 @@ module Zeus
     #   4. ClientHandler forwards the pid to the client over S_CLI.
     #
     class ClientHandler
-      def datasource ; @server ; end
+      def datasource          ; @listener ; end
       def on_datasource_event ; handle_server_connection ; end
+      def close_child_socket  ; end
+      def close_parent_socket ; @listener.close ; end
 
-      def initialize(acceptor_commands, registration_monitor)
-        @reg_monitor = registration_monitor
+      def initialize(acceptor_commands, server)
+        @server = server
         @acceptor_commands = acceptor_commands
-        @server = UNIXServer.new(Zeus::SOCKET_NAME)
-        @server.listen(10)
+        @listener = UNIXServer.new(Zeus::SOCKET_NAME)
+        @listener.listen(10)
       rescue Errno::EADDRINUSE
         Zeus.ui.error "Zeus appears to be already running in this project. If not, remove .zeus.sock and try again."
         exit 1
       end
 
       def handle_server_connection
-        s_client = @server.accept
+        s_client = @listener.accept
 
         # 1
         data = JSON.parse(s_client.readline.chomp)
@@ -76,7 +78,8 @@ module Zeus
         regmsg = {type: 'wait', command: command}
 
         s, r = UNIXSocket.pair
-        @reg_monitor.acceptor_registration_socket.send_io(r)
+
+        @server.__CHILD__register_acceptor(r)
         s << "#{regmsg.to_json}\n"
 
         s.readline # wait
@@ -99,7 +102,7 @@ module Zeus
             s_client, client_terminal,
             "no such command `#{command}`.")
         end
-        acceptor = @reg_monitor.find_acceptor_for_command(command)
+        acceptor = @server.__CHILD__find_acceptor_for_command(command)
         unless acceptor
           wait_for_acceptor(
             s_client, client_terminal, command,

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

@@ -6,8 +6,10 @@ module Zeus
       class FSEvent
         WRAPPER_PATH = File.expand_path("../../../../../ext/fsevents-wrapper/fsevents-wrapper", __FILE__)
 
-        def datasource ; @io_out ; end
+        def datasource          ; @io_out ; end
         def on_datasource_event ; handle_changed_files ; end
+        def close_child_socket  ; end
+        def close_parent_socket ; [@io_in, @io_out].each(&:close) ; end
 
         def initialize(&change_callback)
           @change_callback = change_callback
@@ -17,13 +19,8 @@ module Zeus
         end
 
         def handle_changed_files
-          50.times {
-            begin
-              read_and_notify_files
-            rescue Errno::EAGAIN
-              break
-            end
-          }
+          50.times { read_and_notify_files }
+        rescue Errno::EAGAIN
         end
 
         def read_and_notify_files
@@ -42,7 +39,6 @@ module Zeus
         def watch(file)
           return false if @watched_files[file]
           @watched_files[file] = true
-          File.open('a.log', 'a') { |f| f.puts file }
           @io_in.puts file
           true
         end

data/lib/zeus/server/process_tree.rb

@@ -0,0 +1,78 @@
+module Zeus
+  class Server
+    class ProcessTree
+      class Node
+        attr_accessor :pid, :children, :features
+        def initialize(pid)
+          @pid, @children, @features = pid, [], {}
+        end
+
+        def add_child(node)
+          self.children << node
+        end
+
+        def add_feature(feature)
+          self.features[feature] = true
+        end
+
+        def has_feature?(feature)
+          self.features[feature] == true
+        end
+
+        def inspect
+          "(#{pid}:#{features.size}:[#{children.map(&:inspect).join(",")}])"
+        end
+
+      end
+
+      def inspect
+        @root.inspect
+      end
+
+      def initialize
+        @root = Node.new(Process.pid)
+        @nodes_by_pid = {Process.pid => @root}
+      end
+
+      def node_for_pid(pid)
+        @nodes_by_pid[pid.to_i] ||= Node.new(pid.to_i)
+      end
+
+      def process_has_parent(pid, ppid)
+        curr = node_for_pid(pid)
+        base = node_for_pid(ppid)
+        base.add_child(curr)
+      end
+
+      def process_has_feature(pid, feature)
+        node = node_for_pid(pid)
+        node.add_feature(feature)
+      end
+
+      def kill_node(node)
+        @nodes_by_pid.delete(node.pid)
+        # recall that this process explicitly traps INT -> exit 0
+        Process.kill("INT", node.pid)
+      end
+
+      def kill_nodes_with_feature(file, base = @root)
+        if base.has_feature?(file)
+          if base == @root.children[0] || base == @root
+            Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
+            return false
+          end
+          kill_node(base)
+          return true
+        else
+          base.children.dup.each do |node|
+            if kill_nodes_with_feature(file, node)
+              base.children.delete(node)
+            end
+          end
+          return false
+        end
+      end
+
+    end
+  end
+end

data/lib/zeus/server/process_tree_monitor.rb

@@ -1,97 +1,71 @@
 module Zeus
   class Server
     class ProcessTreeMonitor
+      PID_TYPE = "P"
+      FEATURE_TYPE = "F"
 
-      def initialize
+      def datasource          ; @sock ; end
+      def on_datasource_event ; handle_messages ; end
+      def close_child_socket  ; @__CHILD__sock.close ; end
+      def close_parent_socket ; @sock.close ; end
+
+      def initialize(file_monitor)
         @tree = ProcessTree.new
+        @file_monitor = file_monitor
+
+        @sock, @__CHILD__sock = Socket.pair(:UNIX, :DGRAM)
       end
 
       def kill_nodes_with_feature(file)
         @tree.kill_nodes_with_feature(file)
       end
 
-      def process_has_feature(pid, file)
-        @tree.process_has_feature(pid, file)
+      def handle_messages
+        50.times { handle_message }
+      rescue Errno::EAGAIN
       end
 
-      def process_has_parent(pid, ppid)
-        @tree.process_has_parent(pid, ppid)
-      end
-
-      class ProcessTree
-        class Node
-          attr_accessor :pid, :children, :features
-          def initialize(pid)
-            @pid, @children, @features = pid, [], {}
-          end
-
-          def add_child(node)
-            self.children << node
-          end
-
-          def add_feature(feature)
-            self.features[feature] = true
-          end
-
-          def has_feature?(feature)
-            self.features[feature] == true
-          end
-
-          def inspect
-            "(#{pid}:#{features.size}:[#{children.map(&:inspect).join(",")}])"
-          end
-
-        end
-
-        def inspect
-          @root.inspect
-        end
-
-        def initialize
-          @root = Node.new(Process.pid)
-          @nodes_by_pid = {Process.pid => @root}
+      def handle_message
+        data = @sock.recv_nonblock(1024)
+        case data[0]
+        when FEATURE_TYPE
+          handle_feature_message(data[1..-1])
+        when PID_TYPE
+          handle_pid_message(data[1..-1])
+        else
+          raise "Unrecognized message"
         end
+      end
 
-        def node_for_pid(pid)
-          @nodes_by_pid[pid.to_i] ||= Node.new(pid.to_i)
-        end
+      def handle_pid_message(data)
+        data =~ /(\d+):(\d+)/
+          pid, ppid = $1.to_i, $2.to_i
+        @tree.process_has_parent(pid, ppid)
+      end
 
-        def process_has_parent(pid, ppid)
-          curr = node_for_pid(pid)
-          base = node_for_pid(ppid)
-          base.add_child(curr)
-        end
+      def handle_feature_message(data)
+        data =~ /(\d+):(.*)/
+          pid, file = $1.to_i, $2
+        @tree.process_has_feature(pid, file)
+        @file_monitor.watch(file)
+      end
 
-        def process_has_feature(pid, feature)
-          node = node_for_pid(pid)
-          node.add_feature(feature)
-        end
 
-        def kill_node(node)
-          @nodes_by_pid.delete(node.pid)
-          # recall that this process explicitly traps INT -> exit 0
-          Process.kill("INT", node.pid)
+      module ChildProcessApi
+        def __CHILD__send_pid(message)
+          @__CHILD__sock.send(PID_TYPE + message, 0)
+        rescue Errno::ENOBUFS
+          sleep 0.2
+          retry
         end
 
-        def kill_nodes_with_feature(file, base = @root)
-          if base.has_feature?(file)
-            if base == @root.children[0] || base == @root
-              Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
-              return false
-            end
-            kill_node(base)
-            return true
-          else
-            base.children.dup.each do |node|
-              if kill_nodes_with_feature(file, node)
-                base.children.delete(node)
-              end
-            end
-            return false
-          end
+        def __CHILD__send_feature(message)
+          @__CHILD__sock.send(FEATURE_TYPE + message, 0)
+        rescue Errno::ENOBUFS
+          sleep 0.2
+          retry
         end
-
-      end
+      end ; include ChildProcessApi
 
     end
   end

data/lib/zeus/server/stage.rb

@@ -1,5 +1,7 @@
 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)
 
@@ -10,7 +12,7 @@ module Zeus
       end
 
       def notify_feature(feature)
-        @server.w_feature "#{Process.pid}:#{feature}"
+        @server.__CHILD__pid_has_feature(Process.pid, feature)
       end
 
       def descendent_acceptors
@@ -43,11 +45,13 @@ module Zeus
         sleep
       end
 
-      def run
+      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}"
-          pid = Process.pid
-          @server.w_pid "#{pid}:#{Process.ppid}"
+          @server.__CHILD__pid_has_ppid(Process.pid, Process.ppid)
 
           Zeus.ui.as_zeus("starting spawner `#{@name}`")
           trap("INT") {

data/lib/zeus/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -39,6 +39,7 @@ files:
 - lib/zeus/server/client_handler.rb
 - lib/zeus/server/file_monitor.rb
 - lib/zeus/server/file_monitor/fsevent.rb
+- lib/zeus/server/process_tree.rb
 - lib/zeus/server/process_tree_monitor.rb
 - lib/zeus/server/stage.rb
 - lib/zeus/templates/rails.rb