zeus 0.1.0 → 0.2.0.beta1

data/lib/zeus/server/acceptor_registration_monitor.rb

@@ -0,0 +1,44 @@
+module Zeus
+  class Server
+    class AcceptorRegistrationMonitor
+
+      def datasource          ; @reg_monitor ; end
+      def on_datasource_event ; handle_registration ; end
+
+      def initialize
+        # note: if these aren't ivars, they go out of scope, get GC'd,
+        # and cause the UNIXSockets to quit working... often in perplexing ways.
+        @s, @r = Socket.pair(:UNIX, :DGRAM)
+        @reg_monitor  = UNIXSocket.for_fd(@s.fileno)
+        @reg_acceptor = UNIXSocket.for_fd(@r.fileno)
+        @acceptors = []
+      end
+
+      AcceptorStub = Struct.new(:pid, :socket, :commands, :description)
+
+      def handle_registration
+        io = @reg_monitor.recv_io
+
+        data = JSON.parse(io.readline.chomp)
+        pid         = data['pid'].to_i
+        commands    = data['commands']
+        description = data['description']
+
+        @acceptors.reject!{|ac|ac.commands == commands}
+        @acceptors << AcceptorStub.new(pid, io, commands, description)
+      end
+
+      def find_acceptor_for_command(command)
+        @acceptors.detect { |acceptor|
+          acceptor.commands.include?(command)
+        }
+      end
+
+      def acceptor_registration_socket
+        @reg_acceptor
+      end
+
+    end
+
+  end
+end

data/lib/zeus/server/client_handler.rb

@@ -0,0 +1,88 @@
+require 'socket'
+require 'json'
+
+require 'zeus/server/acceptor'
+
+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
+      SERVER_SOCK = ".zeus.sock"
+
+      def datasource ; @server ; end
+      def on_datasource_event ; handle_server_connection ; end
+
+      def initialize(registration_monitor)
+        @reg_monitor = registration_monitor
+        begin
+          @server = UNIXServer.new(SERVER_SOCK)
+          @server.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
+        # ensure
+        #   @server.close rescue nil
+        #   File.unlink(SERVER_SOCK)
+        end
+      end
+
+      def handle_server_connection
+        s_client = @server.accept
+        fork { handshake_client_to_acceptor(s_client) }
+      end
+
+      #  client clienthandler acceptor
+      # 1  ---------->                | {command: String, arguments: [String]}
+      # 2  ---------->                | Terminal IO
+      # 3            ----------->     | Terminal IO
+      # 4            ----------->     | Arguments (json array)
+      # 5            <-----------     | pid
+      # 6  <---------                 | pid
+      def handshake_client_to_acceptor(s_client)
+        # 1
+        data = JSON.parse(s_client.readline.chomp)
+        command, arguments = data.values_at('command', 'arguments')
+
+        # 2
+        client_terminal = s_client.recv_io
+
+        # 3
+        acceptor = @reg_monitor.find_acceptor_for_command(command)
+        usock = UNIXSocket.for_fd(acceptor.socket.fileno)
+        # TODO handle nothing found
+        usock.send_io(client_terminal)
+
+        puts "accepting connection for #{command}"
+
+        # 4
+        acceptor.socket.puts arguments.to_json
+
+        # 5
+        pid = acceptor.socket.readline.chomp.to_i
+
+        # 6
+        s_client.puts pid
+      end
+
+    end
+  end
+end

data/lib/zeus/server/file_monitor.rb

@@ -0,0 +1,57 @@
+require 'rb-kqueue'
+
+module Zeus
+  class Server
+    class FileMonitor
+
+      TARGET_FD_LIMIT = 8192
+
+      def initialize(&change_callback)
+        configure_file_descriptor_resource_limit
+        @queue = KQueue::Queue.new
+        @watched_files = {}
+        @deleted_files = []
+        @change_callback = change_callback
+      end
+
+      def process_events
+        @queue.poll
+      end
+
+      def watch(file)
+        return if @watched_files[file]
+        @watched_files[file] = true
+        @queue.watch_file(file, :write, :extend, :rename, :delete, &method(:file_did_change))
+      rescue Errno::ENOENT
+        Zeus.ui.debug("No file found at #{file}")
+      end
+
+      private
+
+      def file_did_change(event)
+        Zeus.ui.info("Dependency change at #{event.watcher.path}")
+        resubscribe_deleted_file(event) if event.flags.include?(:delete)
+        @change_callback.call(event.watcher.path)
+      end
+
+      def configure_file_descriptor_resource_limit
+        limit = Process.getrlimit(Process::RLIMIT_NOFILE)
+        if limit[0] < TARGET_FD_LIMIT && limit[1] >= TARGET_FD_LIMIT
+          Process.setrlimit(Process::RLIMIT_NOFILE, TARGET_FD_LIMIT)
+        else
+          puts "\x1b[33m[zeus] Warning: increase the max number of file descriptors. If you have a large project, this max cause a crash in about 10 seconds.\x1b[0m"
+        end
+      end
+
+      def resubscribe_deleted_file(event)
+        event.watcher.disable!
+        begin
+          @queue.watch_file(event.watcher.path, :write, :extend, :rename, :delete, &method(:file_did_change))
+        rescue Errno::ENOENT
+          @deleted_files << event.watcher.path
+        end
+      end
+
+    end
+  end
+end

data/lib/zeus/server/process_tree_monitor.rb

@@ -0,0 +1,98 @@
+module Zeus
+  class Server
+    class ProcessTreeMonitor
+
+      def initialize
+        @tree = ProcessTree.new
+      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)
+      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}
+        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
+              puts "\x1b[31mOne of zeus's dependencies changed. Not killing zeus. You may have to restart the server.\x1b[0m"
+              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
+end

data/lib/zeus/server/stage.rb

@@ -0,0 +1,57 @@
+module Zeus
+  class Server
+    class Stage
+
+      attr_accessor :name, :stages, :actions
+      attr_reader :pid
+      def initialize(server)
+        @server = server
+      end
+
+      # There are a few things we want to accomplish:
+      # 1. Running all the actions (each time this stage is killed and restarted)
+      # 2. Starting all the substages (and restarting them when necessary)
+      # 3. Starting all the acceptors (and restarting them when necessary)
+      def run
+        @pid = fork {
+          $0 = "zeus spawner: #{@name}"
+          pid = Process.pid
+          @server.w_pid "#{pid}:#{Process.ppid}"
+          puts "\x1b[35m[zeus] starting spawner `#{@name}`\x1b[0m"
+          trap("INT") {
+            puts "\x1b[35m[zeus] killing spawner `#{@name}`\x1b[0m"
+            exit 0
+          }
+
+          @actions.each(&:call)
+
+          pids = {}
+          @stages.each do |stage|
+            pids[stage.run] = stage
+          end
+
+          $LOADED_FEATURES.each do |f|
+            @server.w_feature "#{pid}:#{f}"
+          end
+
+          loop do
+            begin
+              pid = Process.wait
+            rescue Errno::ECHILD
+              raise "Stage `#{@name}` has no children. All terminal nodes must be acceptors"
+            end
+            if (status = $?.exitstatus) > 0
+              exit status
+            else # restart the stage that died.
+              stage = pids[pid]
+              pids[stage.run] = stage
+            end
+          end
+
+        }
+      end
+
+    end
+
+  end
+end

data/{examples → lib/zeus/templates}/rails.rb

@@ -24,18 +24,20 @@ Zeus::Server.define! do
           Rails.application.require_environment!
         end
 
-        acceptor :generate, ".zeus.dev_generate.sock" do
+        command :generate, :g do
           require 'rails/commands/generate'
         end
-        acceptor :runner, ".zeus.dev_runner.sock" do
+
+        command :runner, :r do
           require 'rails/commands/runner'
         end
-        acceptor :console, ".zeus.dev_console.sock" do
+
+        command :console, :c do
           require 'rails/commands/console'
           Rails::Console.start(Rails.application)
         end
 
-        acceptor :server, ".zeus.dev_server.sock" do
+        command :server, :s do
           require 'rails/commands/server'
           server = Rails::Server.new
           Dir.chdir(Rails.application.root)
@@ -48,7 +50,7 @@ Zeus::Server.define! do
             load 'Rakefile'
           end
 
-          acceptor :rake, ".zeus.dev_rake.sock" do
+          command :rake do
             Rake.application.run
           end
 
@@ -63,12 +65,10 @@ Zeus::Server.define! do
           Rails.application.require_environment!
         end
 
-        acceptor :testrb, ".zeus.test_testrb.sock" do
-          forkpoint testrb: acceptor(".zeus.test_testrb.sock") {
-            (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
-              abort r.options.banner + " tests..."
-            exit r.run
-          }
+        command :testrb do
+          (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
+            abort r.options.banner + " tests..."
+          exit r.run
         end
 
       end

data/lib/zeus/ui.rb

@@ -0,0 +1,56 @@
+module Zeus
+  class UI
+
+    def initialize
+      @quiet = false
+      @debug = ENV['DEBUG']
+    end
+
+    def info(msg)
+      tell_me(msg, nil) if !@quiet
+    end
+
+    def confirm(msg)
+      tell_me(msg, :green) if !@quiet
+    end
+
+    def warn(msg)
+      tell_me(msg, :yellow)
+    end
+
+    def error(msg)
+      tell_me(msg, :red)
+    end
+
+    def be_quiet!
+      @quiet = true
+    end
+
+    def debug?
+      # needs to be false instead of nil to be newline param to other methods
+      !!@debug && !@quiet
+    end
+
+    def debug!
+      @debug = true
+    end
+
+    def debug(msg)
+      tell_me(msg, nil) if debug?
+    end
+
+    private
+    def tell_me(msg, color = nil)
+      msg = case color
+            when :red    ; "\x1b[31m#{msg}\x1b[0m"
+            when :green  ; "\x1b[32m#{msg}\x1b[0m"
+            when :yellow ; "\x1b[33m#{msg}\x1b[0m"
+            else         ; msg
+            end
+      puts msg
+    end
+
+
+  end
+
+end