zeus 0.4.5 → 0.4.6

data/README.md

@@ -27,7 +27,7 @@ Install the gem.
 
 Q: "I should put it in my `Gemfile`, right?"
 
-A: No. running `bundle exec zeus` instead of `zeus` can add precious seconds to a command that otherwise would take 200ms. Zeus was built to be run from outside of bundler.
+A: You can, but running `bundle exec zeus` instead of `zeus` can add precious seconds to a command that otherwise would take 200ms. Zeus was built to be run from outside of bundler.
 
 ## Usage
 
@@ -57,6 +57,7 @@ Check [Rails tests](https://github.com/burke/zeus-extended-testcases) if you cha
 
 ## Thanks...
 
+* To [Michael Grosser](http://github.com/grosser) for various contributions
 * To [Stefan Penner](http://github.com/stefanpenner) for discussion and various contributions.
 * To [Samuel Kadolph](http://github.com/samuelkadolph) for doing most of the cross-process pseudoterminal legwork.
 * To [Jesse Storimer](http://github.com/jstorimer) for spin, part of the inspiration for this project

data/Rakefile

@@ -1,7 +1,13 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
 
-require 'rspec'
-task :default do
-  RSpec::Core::Runner.run(Dir.glob("spec/**/*_spec.rb"))
+require 'rspec/core/rake_task'
+task :spec do
+  raise "tests do not work with bundle exec" if defined?(Bundler)
+  desc "Run specs under spec/"
+  RSpec::Core::RakeTask.new do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+  end
 end
+
+task default: :spec

data/bin/zeus

@@ -1,4 +1,8 @@
 #!/usr/bin/env ruby
 
+if defined?(Bundler)
+  puts "\x1b[34mDon't run Zeus with `bundle exec`. It's unnecessarily slow.\x1b[0m"
+end
+
 require 'zeus'
 Zeus::CLI.start

data/docs/acceptor_registration.md

@@ -0,0 +1,14 @@
+# Acceptor Registration
+
+When an acceptor is booted, it registers itself with the master process through UNIX Sockets. Specifically, it talks to the `AcceptorRegistrationMonitor`.
+
+Here's an overview of the registration process:
+
+1. `AcceptorRegistrationMonitor` creates a socketpair for Acceptor registration (`S_REG`)
+2. When an `Acceptor` is started, it:
+  1. Creates a new socketpair for communication with the master process (`S_ACC`)
+  2. Sends one side of `S_ACC` over `S_REG` to the master.
+  3. Sends its pid and then a newline character over `S_REG`.
+3. `AcceptorRegistrationMonitor` receives first the IO and then the pid, and stores them for later reference.
+
+

data/docs/client_server_handshake.md

@@ -0,0 +1,25 @@
+# Client/Server handshake
+
+This takes place in `lib/zeus/server/client_handler.rb`, `lib/zeus/client.rb`, and `lib/zeus/server/acceptor.rb`.
+
+The model is kind of convoluted, so here's an explanation of what's happening with all these sockets:
+
+## Running a command
+1. ClientHandler has a UNIXServer (`SVR`) listening.
+2. ClientHandler has a socketpair with the acceptor referenced by the command (see `docs/acceptor_registration.md`) (`S_ACC`)
+3. When clienthandler receives 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`.
+
+
+## A sort of network diagram
+     client clienthandler acceptor
+    1  ---------->                | {command: String, arguments: [String]}
+    2  ---------->                | Terminal IO
+    3            ----------->     | Terminal IO
+    4            ----------->     | Arguments (json array)
+    5            <-----------     | pid
+    6  <---------                 | pid
+

data/lib/zeus.rb

@@ -1,13 +1,14 @@
+require 'zeus/version'
+require 'zeus/ui'
+require 'zeus/plan'
+require 'zeus/server'
+require 'zeus/client'
+require 'zeus/error_printer'
+require 'zeus/cli'
+
 module Zeus
   SOCKET_NAME = '.zeus.sock'
 
-  autoload :UI,      'zeus/ui'
-  autoload :CLI,     'zeus/cli'
-  autoload :DSL,     'zeus/dsl'
-  autoload :Server,  'zeus/server'
-  autoload :Client,  'zeus/client'
-  autoload :VERSION, 'zeus/version'
-
   class ZeusError < StandardError
     def self.status_code(code)
       define_method(:status_code) { code }
@@ -32,4 +33,15 @@ module Zeus
     @after_fork = []
   end
 
+  def self.thread_with_backtrace_on_error(&b)
+    Thread.new {
+      begin
+        b.call
+      rescue => e
+        ErrorPrinter.new(e).write_to($stdout)
+      end
+    }
+  end
+
 end
+

data/lib/zeus/client.rb

@@ -11,14 +11,18 @@ require "json"
 require "pty"
 require "socket"
 
+require 'zeus/client/winsize'
+
 module Zeus
   class Client
+    include Winsize
 
     attr_accessor :pid
 
     SIGNALS = {
       "\x03" => "INT",
-      "\x1C" => "QUIT"
+      "\x1C" => "QUIT",
+      "\x1A" => "TSTP",
     }
     SIGNAL_REGEX = Regexp.union(SIGNALS.keys)
 
@@ -29,62 +33,55 @@ module Zeus
     def run(command, args)
       maybe_raw do
         PTY.open do |master, slave|
+          @exit_status, @es2 = IO.pipe
           @master = master
           set_winsize
-
-          @winch = make_winch_channel
+          make_winch_channel
           @pid = connect_to_server(command, args, slave)
 
-          buffer = ""
-          begin
-            while ready = select([@winch, @master, $stdin])[0]
-              handle_winch          if ready.include?(@winch)
-              handle_stdin(buffer)  if ready.include?($stdin)
-              handle_master(buffer) if ready.include?(@master)
-            end
-          rescue EOFError
-          end
+          select_loop!
         end
       end
     end
 
     private
 
+    def select_loop!
+      buffer = ""
+      while ready = select([winch, @master, $stdin, @exit_status])[0]
+        handle_winch          if ready.include?(winch)
+        handle_stdin(buffer)  if ready.include?($stdin)
+        handle_master(buffer) if ready.include?(@master)
+        handle_exit           if ready.include?(@exit_status)
+      end
+    rescue EOFError
+    end
+
+    def handle_exit
+      exit @exit_status.readline.chomp.to_i
+    end
+
     def connect_to_server(command, arguments, slave, socket_path = Zeus::SOCKET_NAME)
       socket = UNIXSocket.new(socket_path)
       socket << {command: command, arguments: arguments}.to_json << "\n"
       socket.send_io(slave)
+      socket.send_io(@es2)
       slave.close
 
       pid = socket.readline.chomp.to_i
+      trap("CONT") { Process.kill("CONT", @pid) }
+      pid
     rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ECONNRESET
       # we need a \r at the end because the terminal is in raw mode.
-      # we need to reset the cursor to position 0
       Zeus.ui.error "Zeus doesn't seem to be running, try 'zeus start`\r"
       exit 1
     end
 
-    def make_winch_channel
-      winch, winch_ = IO.pipe
-      trap("WINCH") { winch_ << "\0" }
-      winch
-    end
-
-    def handle_winch
-      @winch.read(1)
-      set_winsize
-      begin
-        Process.kill("WINCH", pid) if pid
-      rescue Errno::ESRCH
-        exit # the remote process died. Just quit.
-      end
-    end
-
     def handle_stdin(buffer)
       input = $stdin.readpartial(4096, buffer)
       input.scan(SIGNAL_REGEX).each { |signal|
         begin
-          Process.kill(SIGNALS[signal], pid)
+          send_signal(signal, pid)
         rescue Errno::ESRCH
           exit # the remote process died. Just quit.
         end
@@ -92,12 +89,17 @@ module Zeus
       @master << input
     end
 
-    def handle_master(buffer)
-      $stdout << @master.readpartial(4096, buffer)
+    def send_signal(signal, pid)
+      if SIGNALS[signal] == "TSTP"
+        Process.kill("STOP", pid)
+        Process.kill("TSTP", Process.pid)
+      else
+        Process.kill(SIGNALS[signal], pid)
+      end
     end
 
-    def set_winsize
-      $stdout.tty? and @master.winsize = $stdout.winsize
+    def handle_master(buffer)
+      $stdout << @master.readpartial(4096, buffer)
     end
 
     def maybe_raw(&b)
@@ -110,5 +112,3 @@ module Zeus
 
   end
 end
-
-__FILE__ == $0 and Zeus::Client.run

data/lib/zeus/client/winsize.rb

@@ -0,0 +1,28 @@
+module Zeus
+  class Client
+    module Winsize
+
+      attr_reader :winch
+
+      def set_winsize
+        $stdout.tty? and @master.winsize = $stdout.winsize
+      end
+
+      def make_winch_channel
+        @winch, winch_ = IO.pipe
+        trap("WINCH") { winch_ << "\0" }
+      end
+
+      def handle_winch
+        @winch.read(1)
+        set_winsize
+        begin
+          Process.kill("WINCH", pid) if pid
+        rescue Errno::ESRCH
+          exit # the remote process died. Just quit.
+        end
+      end
+
+    end
+  end
+end

data/lib/zeus/error_printer.rb

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,50 @@
+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