zeus 0.4.6 → 0.10.0.pre

data/lib/zeus/error_printer.rb

@@ -1,16 +0,0 @@
-module Zeus
-  class ErrorPrinter
-    attr_reader :error
-    def initialize(error)
-      @error = error
-    end
-
-    def write_to(io)
-      io.puts "#{error.backtrace[0]}: #{error.message} (#{error.class})"
-      error.backtrace[1..-1].each do |line|
-        io.puts "\tfrom #{line}"
-      end
-    end
-
-  end
-end

data/lib/zeus/plan.rb

@@ -1,18 +0,0 @@
-require 'set'
-
-require 'zeus/plan/node'
-require 'zeus/plan/stage'
-require 'zeus/plan/acceptor'
-
-module Zeus
-  module Plan
-    class Evaluator
-      def stage(name, &b)
-        stage = Plan::Stage.new(name)
-        stage.root = true
-        stage.instance_eval(&b)
-        stage
-      end
-    end
-  end
-end

data/lib/zeus/plan/acceptor.rb

@@ -1,38 +0,0 @@
-module Zeus
-  module Plan
-
-    class Acceptor < Node
-
-      attr_reader :name, :aliases, :description, :action
-      def initialize(name, aliases, description, &b)
-        super(name)
-        @description = description
-        @aliases = aliases
-        @action = b
-      end
-
-      # ^ configuration
-      # V later use
-
-      def commands
-        [name, *aliases].map(&:to_s)
-      end
-
-      def acceptors
-        self
-      end
-
-      def to_process_object(server)
-        Zeus::Server::Acceptor.new(server).tap do |stage|
-          stage.name = @name
-          stage.aliases = @aliases
-          stage.action = @action
-          stage.description = @description
-        end
-      end
-
-    end
-
-  end
-end
-

data/lib/zeus/plan/node.rb

@@ -1,66 +0,0 @@
-module Zeus
-  module Plan
-
-    class Node
-      attr_reader :name, :stages, :features
-      attr_accessor :pid, :root
-
-      def initialize(name)
-        @name     = name
-        @stages   = []
-        @features = Set.new # hash might be faster than ruby's inane impl of set.
-      end
-
-      def stage_has_feature(name, file)
-        node_for_name(name).features << file
-      end
-
-      def stage_has_pid(name, pid)
-        node_for_name(name).pid = pid
-      end
-
-      def kill_nodes_with_feature(file)
-        if features.include?(file)
-          if root
-            Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
-          else
-            kill!
-          end
-        else
-          stages.each do |child|
-            child.kill_nodes_with_feature(file)
-          end
-        end
-      end
-
-      # We send STOP before actually killing the processes here.
-      # This is to prevent parents from respawning before all the children
-      # are killed. This prevents a race condition.
-      def kill!
-        Process.kill("STOP", pid) if pid
-        # Protected methods don't work with each(&:m) notation.
-        stages.each { |stage| stage.kill! }
-        old_pid  = pid
-        self.pid = nil
-        Process.kill("KILL", old_pid) if old_pid
-      end
-
-      private
-
-      def node_for_name(name)
-        @nodes_by_name ||= __nodes_by_name
-        @nodes_by_name[name]
-      end
-
-      def __nodes_by_name
-        nodes = {name => self}
-        stages.each do |child|
-          nodes.merge!(child.__nodes_by_name)
-        end
-        nodes
-      end ; protected :__nodes_by_name
-
-    end
-
-  end
-end

data/lib/zeus/plan/stage.rb

@@ -1,50 +0,0 @@
-module Zeus
-  module Plan
-
-    class Stage < Node
-
-      attr_reader :actions
-      def initialize(name)
-        super(name)
-        @actions = []
-      end
-
-      def action(&b)
-        @actions << b
-        self
-      end
-
-      def desc(desc)
-        @desc = desc
-      end
-
-      def stage(name, &b)
-        @stages << Plan::Stage.new(name).tap { |s| s.instance_eval(&b) }
-        self
-      end
-
-      def command(name, *aliases, &b)
-        @stages << Plan::Acceptor.new(name, aliases, @desc, &b)
-        @desc = nil
-        self
-      end
-
-      # ^ configuration
-      # V later use
-
-      def acceptors
-        stages.map(&:acceptors).flatten
-      end
-
-      def to_process_object(server)
-        Zeus::Server::Stage.new(server).tap do |stage|
-          stage.name = @name
-          stage.stages = @stages.map { |stage| stage.to_process_object(server) }
-          stage.actions = @actions
-        end
-      end
-
-    end
-
-  end
-end

data/lib/zeus/server.rb

@@ -1,103 +0,0 @@
-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
-
-    def self.define!(&b)
-      @@definition = Zeus::Plan::Evaluator.new.instance_eval(&b)
-    end
-
-    def self.acceptors
-      defined?(@@definition) ? @@definition.acceptors : []
-    end
-
-    def initialize
-      @file_monitor                  = FileMonitor::FSEvent.new(&method(:dependency_did_change))
-      @acceptor_registration_monitor = AcceptorRegistrationMonitor.new
-      @process_tree_monitor          = ProcessTreeMonitor.new(@file_monitor, @@definition)
-      @client_handler                = ClientHandler.new(acceptor_commands, self)
-
-      @plan = @@definition.to_process_object(self)
-    end
-
-    def dependency_did_change(file)
-      @process_tree_monitor.kill_nodes_with_feature(file)
-    end
-
-    def monitors
-      [@file_monitor, @process_tree_monitor, @acceptor_registration_monitor, @client_handler]
-    end
-
-    def run
-      $0 = "zeus master"
-      trap("TERM") { 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 { cleanup_all_children if Process.pid == master }
-      monitors.each(&:close_child_socket)
-
-      runloop!
-    ensure
-      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
-    end
-
-    def extra_features
-      $extra_loaded_features || []
-    end
-
-    # Child process API
-    def __CHILD__close_parent_sockets
-      monitors.each(&:close_parent_socket)
-    end
-
-    def_delegators :@acceptor_registration_monitor,
-      :__CHILD__register_acceptor,
-      :__CHILD__find_acceptor_for_command
-
-    def_delegators :@process_tree_monitor,
-      :__CHILD__stage_starting_with_pid,
-      :__CHILD__stage_has_feature
-
-    private
-
-    def acceptor_commands
-      self.class.acceptors.map(&:commands).flatten
-    end
-
-    def runloop!
-      loop do
-        ready, = IO.select(monitors.map(&:datasource), [], [], 1)
-        next unless ready
-        monitors.each do |m|
-          m.on_datasource_event if ready.include?(m.datasource)
-        end
-      end
-    end
-
-  end
-end

data/lib/zeus/server/acceptor.rb

@@ -1,79 +0,0 @@
-require 'json'
-require 'socket'
-
-module Zeus
-  class Server
-    class Acceptor
-      attr_accessor :aliases, :description, :action, :name
-      def initialize(server)
-        @server = server
-      end
-
-      def descendent_acceptors
-        self
-      end
-
-      def run
-        register_with_client_handler(Process.pid)
-        Zeus.ui.info("starting #{process_type} `#{@name}`")
-        Zeus.thread_with_backtrace_on_error { runloop! }
-      end
-
-      private
-
-      def command_runner
-        CommandRunner.new(name, action, @s_acceptor)
-      end
-
-      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
-
-      def registration_data(pid)
-        {type: 'registration', pid: pid, commands: [name, *aliases], description: description}.to_json
-      end
-
-      def accept_connection
-        terminal = @s_acceptor.recv_io # blocking
-        exit_status_socket = @s_acceptor.recv_io
-        arguments = JSON.parse(@s_acceptor.readline.chomp)
-
-        [terminal, exit_status_socket, arguments]
-      end
-
-      def process_type
-        "acceptor"
-      end
-
-      def runloop!
-        loop do
-          terminal, exit_status_socket, arguments = accept_connection # blocking
-          command_runner.run(terminal, exit_status_socket, arguments)
-        end
-      end
-
-      module ErrorState
-        NOT_A_PID = 0
-        attr_accessor :error
-
-        def process_type
-          "error-state acceptor"
-        end
-
-        def runloop!
-          loop do
-            terminal = @s_acceptor.recv_io
-            _ = @s_acceptor.readline
-            @s_acceptor << NOT_A_PID << "\n"
-            ErrorPrinter.new(@error).write_to(terminal)
-            terminal.close
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/zeus/server/acceptor_registration_monitor.rb

@@ -1,75 +0,0 @@
-module Zeus
-  class Server
-    class AcceptorRegistrationMonitor
-
-      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
-      # on behalf of unbooted acceptors
-      def close_child_socket  ; end
-      def close_parent_socket ; @sock.close ; end
-
-      def initialize
-        @sock, @__CHILD__sock = UNIXSocket.pair
-        @acceptors = []
-        @pings = {}
-      end
-
-      AcceptorStub = Struct.new(:pid, :socket, :commands, :description)
-
-      def handle_message
-        io = @sock.recv_io
-
-        data = JSON.parse(io.readline.chomp)
-        type = data['type']
-
-        case type
-        when 'wait' ; handle_wait(io, data)
-        when 'registration' ; handle_registration(io, data)
-        else raise "invalid message"
-        end
-      end
-
-      def handle_wait(io, data)
-        command = data['command'].to_s
-        @pings[command] ||= []
-        @pings[command] << io
-      end
-
-      def handle_registration(io, data)
-        pid         = data['pid'].to_i
-        commands    = data['commands']
-        description = data['description']
-
-        @acceptors.reject!{|ac|ac.commands == commands}
-        @acceptors << AcceptorStub.new(pid, io, commands, description)
-        notify_pings_for_commands(commands)
-      end
-
-      def notify_pings_for_commands(commands)
-        (commands || []).each do |command|
-          (@pings[command.to_s] || []).each do |ping|
-            ping.puts "ready\n"
-            ping.close
-          end
-          @pings[command.to_s] = nil
-        end
-      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
-  end
-end