zeus 0.4.6 → 0.10.0.pre

data/lib/zeus/server/client_handler.rb

@@ -1,106 +0,0 @@
-require 'socket'
-require 'json'
-
-# This class is a little confusing. See the docs/ directory for guidance.
-module Zeus
-  class Server
-    class ClientHandler
-      def datasource          ; @listener ; end
-      def on_datasource_event ; handle_server_connection ; end
-      def close_child_socket  ; end
-      def close_parent_socket ; @listener.close ; end
-
-      REATTEMPT_HANDSHAKE = 204
-
-      def initialize(acceptor_commands, server)
-        @server = server
-        @acceptor_commands = acceptor_commands
-        @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::SOCKET_NAME} and try again."
-        exit 1
-      end
-
-      private
-
-      # See docs/client_server_handshake.md for details
-      def handle_server_connection
-        s_client = @listener.accept
-
-        data = JSON.parse(s_client.readline.chomp)
-        command, arguments = data.values_at('command', 'arguments')
-
-        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.
-          # If the acceptor is not booted yet, this will hang until it is, then terminate with 
-          # 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_status_socket) ; exit }
-              Process.wait(pid)
-              break if $?.exitstatus != REATTEMPT_HANDSHAKE
-            end
-          ensure
-            client_terminal.close
-            s_client.close
-          end
-        }
-      end
-
-      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, 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
-        pid = acceptor.socket.readline.chomp.to_i
-        s_client.puts pid
-        s_client.close
-      end
-
-      def exit_with_message(s_client, client_terminal, msg)
-        s_client << "0\n"
-        client_terminal << "[zeus] #{msg}\n"
-        client_terminal.close
-        s_client.close
-        exit 1
-      end
-
-      def wait_for_acceptor(s_client, client_terminal, command)
-        s_client << "0\n"
-        client_terminal << "[zeus] waiting for `#{command}` to finish booting...\n"
-
-        s, r = UNIXSocket.pair
-        s << {type: 'wait', command: command}.to_json << "\n"
-        @server.__CHILD__register_acceptor(r)
-
-        s.readline # wait until acceptor is booted
-      end
-
-      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

@@ -1,70 +0,0 @@
-module Zeus
-  class Server
-    class CommandRunner
-
-      def initialize(name, action, s_acceptor)
-        @name = name
-        @action = action
-        @s_acceptor = s_acceptor
-      end
-
-      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, exit_status_socket, arguments)
-        $0 = "zeus runner: #{@name}"
-        @exit_status_socket = exit_status_socket
-        @terminal = terminal
-        Process.setsid
-        reconnect_activerecord!
-        @s_acceptor << $$ << "\n"
-        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
-      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!
-        ActiveRecord::Base.clear_all_connections! rescue nil
-        ActiveRecord::Base.establish_connection   rescue nil
-      end
-
-    end
-  end
-end

data/lib/zeus/server/file_monitor.rb

@@ -1,8 +0,0 @@
-require 'zeus/server/file_monitor/fsevent'
-
-module Zeus
-  class Server
-    module FileMonitor
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require 'open3'
-require 'pathname'
-
-module Zeus
-  class Server
-    module FileMonitor
-      class FSEvent
-        WRAPPER_PATH = File.expand_path("../../../../../ext/fsevents-wrapper/fsevents-wrapper", __FILE__)
-
-        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
-          @io_in, @io_out, @wrapper_thread = open_wrapper
-          @givenpath_to_realpath = {}
-          @realpath_to_givenpath = {}
-          @buffer = ""
-        end
-
-        # The biggest complicating factor here is that ruby doesn't fully resolve
-        # symlinks in paths, but FSEvents does. We resolve all paths fully with
-        # Pathname#realpath, and keep mappings in both directions.
-        # It's conceivable that the same file would be required by two different paths,
-        # so we keep an array and fire callbacks for all given paths matching a real
-        # path when a change is detected.
-        def watch(given)
-          return false if @givenpath_to_realpath[given]
-
-          real = realpath(given)
-          @givenpath_to_realpath[given] = real
-          @realpath_to_givenpath[real] ||= []
-          @realpath_to_givenpath[real] << given
-
-          @io_in.write("#{real}\n")
-          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)
-          Pathname.new(file).realpath.to_s
-        rescue Errno::ENOENT
-          file
-        end
-
-        def open_wrapper
-          Open3.popen2e(WRAPPER_PATH)
-        end
-
-        def handle_changed_files
-          50.times { read_and_notify_files }
-        rescue Stop
-        end
-
-        Stop = Class.new(Exception)
-
-        def read_and_notify_files
-          begin
-            lines = @io_out.read_nonblock(1000)
-          rescue Errno::EAGAIN
-            raise Stop
-          rescue EOFError
-            Zeus.ui.error("fsevents-wrapper crashed.")
-            Process.kill("INT", 0)
-          end
-          files = lines.split("\n")
-          files[0] = "#{@buffer}#{files[0]}" unless @buffer == ""
-          unless lines[-1] == "\n"
-            @buffer = files.pop
-          end
-
-          files.each do |real|
-            file_did_change(real)
-          end
-        end
-
-        def file_did_change(real)
-          realpaths_for_givenpath(real).each do |given|
-            Zeus.ui.info("Dependency change at #{given}")
-            @change_callback.call(given)
-          end
-        end
-
-        def realpaths_for_givenpath(real)
-          @realpath_to_givenpath[real] || []
-        end
-
-      end
-    end
-  end
-end
-
-
-

data/lib/zeus/server/process_tree_monitor.rb

@@ -1,89 +0,0 @@
-module Zeus
-  class Server
-    class ProcessTreeMonitor
-      STARTING_MARKER = "P"
-      FEATURE_MARKER  = "F"
-
-      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)
-        @root = tree
-        @file_monitor = file_monitor
-
-        @sock, @__CHILD__sock = open_socketpair
-      end
-
-      def kill_nodes_with_feature(file)
-        @root.kill_nodes_with_feature(file)
-      end
-
-      def kill_all_nodes
-        @root.kill!
-      end
-
-      module ChildProcessApi
-        def __CHILD__stage_starting_with_pid(name, pid)
-          buffer_send("#{STARTING_MARKER}#{name}:#{pid}")
-        end
-
-        def __CHILD__stage_has_feature(name, feature)
-          buffer_send("#{FEATURE_MARKER}#{name}:#{feature}")
-        end
-
-        private
-
-        def buffer_send(msg)
-          @__CHILD__sock.send(msg, 0)
-        rescue Errno::ENOBUFS
-          sleep 0.2
-          retry
-        end
-
-      end ; include ChildProcessApi
-
-      private
-
-      def handle_messages
-        50.times { handle_message }
-      rescue Stop
-      end
-
-      Stop = Class.new(Exception)
-
-      def handle_message
-        begin
-          data = @sock.recv_nonblock(4096)
-        rescue Errno::EAGAIN
-          raise Stop
-        end
-        case data[0]
-        when STARTING_MARKER
-          handle_starting_message(data[1..-1])
-        when FEATURE_MARKER
-          handle_feature_message(data[1..-1])
-        end
-      end
-
-      def open_socketpair
-        Socket.pair(:UNIX, :DGRAM)
-      end
-
-      def handle_starting_message(data)
-        data =~ /(.+):(\d+)/
-        name, pid = $1.to_sym, $2.to_i
-        @root.stage_has_pid(name, pid)
-      end
-
-      def handle_feature_message(data)
-        data =~ /(.+?):(.*)/
-        name, file = $1.to_sym, $2
-        @root.stage_has_feature(name, file)
-        @file_monitor.watch(file)
-      end
-
-    end
-  end
-end

data/lib/zeus/server/stage.rb

@@ -1,88 +0,0 @@
-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
-
-      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
-
-      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 start_child_stages
-        @pids = {}
-        @stages.each do |stage|
-          @pids[stage.run] = stage
-        end
-      end
-
-      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
-          rescue Errno::ECHILD
-            sleep # if this is a terminal node, just let acceptors run...
-          end
-          stage = @pids[pid]
-          @pids[stage.run] = stage
-        end
-      end
-
-      def notify_started
-        @server.__CHILD__stage_starting_with_pid(@name, Process.pid)
-        Zeus.ui.info("starting #{process_type} `#{@name}`")
-      end
-
-      def notify_terminated
-        Zeus.ui.info("killing #{process_type} `#{@name}`")
-      end
-
-
-      def process_type
-        "spawner"
-      end
-
-    end
-  end
-end