zeus 0.4.5 → 0.4.6

data/lib/zeus/server/stage/error_state.rb

@@ -0,0 +1,42 @@
+module Zeus
+  class Server
+    class Stage
+
+      module ErrorState
+        def handle_load_error(e)
+          errored_file = full_path_of_file_from_error(e)
+
+          # register all the decendent acceptors as stubs with errors
+          register_acceptors_as_errors(e)
+
+          feature_notifier.notify_feature(errored_file)
+          feature_notifier.notify_new_features
+
+          # we do not need to do anything. We wait, until a dependency changes.
+          # At that point, we get killed and restarted.
+          sleep
+        end
+
+        private
+
+        def full_path_of_file_from_error(e)
+          errored_file = e.backtrace[0].scan(/(.+?):\d+:in/)[0][0]
+
+          # handle relative paths
+          unless errored_file =~ /^\//
+            errored_file = File.expand_path(errored_file, Dir.pwd)
+          end
+        end
+
+        def register_acceptors_as_errors(e)
+          descendent_acceptors.each do |acc|
+            acc = acc.extend(Acceptor::ErrorState)
+            acc.error = e
+            acc.run
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/zeus/server/stage/feature_notifier.rb

@@ -0,0 +1,38 @@
+module Zeus
+  class Server
+    class Stage
+      class FeatureNotifier
+
+        def initialize(server, stage_name)
+          @server = server
+          @stage_name = stage_name
+        end
+
+        def notify_new_features
+          new_features = newly_loaded_features()
+          $previously_loaded_features ||= []
+          $previously_loaded_features |= new_features
+          Thread.new {
+            new_features.each { |f| notify_feature(f) }
+          }
+        end
+
+        def notify_feature(feature)
+          @server.__CHILD__stage_has_feature(@stage_name, feature)
+        end
+
+        private
+
+        def newly_loaded_features
+          old_features = defined?($previously_loaded_features) ? $previously_loaded_features : []
+          ($LOADED_FEATURES + @server.extra_features) - old_features
+        end
+
+      end
+    end
+  end
+end
+
+
+
+

data/lib/zeus/version.rb

@@ -1,3 +1,3 @@
 module Zeus
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/spec/error_printer_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+require 'stringio'
+
+module Zeus
+  describe ErrorPrinter do
+
+    let(:error) {
+      begin
+        raise
+      rescue => e
+        e
+      end
+    }
+
+    it 'prints an error just like ruby does by default' do
+      io = StringIO.new
+      ErrorPrinter.new(error).write_to(io)
+      io.rewind
+      lines = io.readlines
+      lines[0].should =~ /^[^\s]*error_printer_spec.rb:\d+:in `.+':  \(RuntimeError\)$/
+      lines[1].should =~ /^\tfrom .*\.rb:\d+:in `.*'$/
+      lines.size.should > 5
+    end
+
+  end
+end

data/spec/integration_spec.rb

@@ -7,22 +7,29 @@ describe "Integration" do
 
   context "in a non-rails project with a .zeus.rb" do
     it "starts the zeus server and responds to commands" do
-      write ".zeus.rb", <<-RUBY
-        Zeus::Server.define! do
-          stage :foo do
-            command :bar do
-              puts "YES"
-            end
-          end
-        end
-      RUBY
-
+      bar_setup("puts 'YES'")
       start, run = start_and_run("bar")
       start.should include "spawner `foo`"
       start.should include "acceptor `bar`"
       run.should == ["YES\r\n"]
     end
 
+    it "receives ARGV after command" do
+      bar_setup("puts ARGV.join(', ')")
+      start, run = start_and_run("bar 1 '2 3 4' --123")
+      run.should == ["1, 2 3 4, --123\r\n"]
+    end
+
+    it "cam exist with 0" do
+      bar_setup("exit 0")
+      start_and_run("bar")
+    end
+
+    it "can exist with non-0" do
+      bar_setup("exit 1")
+      start_and_run("bar", :fail => true)
+    end
+
     it "can run via command alias" do
       write ".zeus.rb", <<-RUBY
         Zeus::Server.define! do
@@ -43,6 +50,18 @@ describe "Integration" do
 
   private
 
+  def bar_setup(inner)
+    write ".zeus.rb", <<-RUBY
+      Zeus::Server.define! do
+        stage :foo do
+          command :bar do
+            #{inner}
+          end
+        end
+      end
+    RUBY
+  end
+
   def zeus(command, options={})
     command = zeus_command(command)
     result = `#{command}`
@@ -62,11 +81,11 @@ describe "Integration" do
     end
   end
 
-  def start_and_run(commands)
+  def start_and_run(commands, options={})
     start_output = ""
     t1 = Thread.new { record_start(start_output) }
     sleep 0.1
-    run_output = [*commands].map{ |cmd| zeus(cmd) }
+    run_output = [*commands].map{ |cmd| zeus(cmd, options) }
     sleep 0.2
     t1.kill
     [start_output, run_output]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-16 00:00:00.000000000 Z
+date: 2012-08-20 00:00:00.000000000 Z
 dependencies: []
 description: Boot any rails app in under a second
 email:
@@ -27,13 +27,20 @@ files:
 - README.md
 - Rakefile
 - bin/zeus
+- docs/acceptor_registration.md
+- docs/client_server_handshake.md
 - ext/fsevents-wrapper/fsevents-wrapper
 - ext/fsevents-wrapper/main.m
 - lib/thrud.rb
 - lib/zeus.rb
 - lib/zeus/cli.rb
 - lib/zeus/client.rb
-- lib/zeus/dsl.rb
+- lib/zeus/client/winsize.rb
+- lib/zeus/error_printer.rb
+- lib/zeus/plan.rb
+- lib/zeus/plan/acceptor.rb
+- lib/zeus/plan/node.rb
+- lib/zeus/plan/stage.rb
 - lib/zeus/server.rb
 - lib/zeus/server/acceptor.rb
 - lib/zeus/server/acceptor_registration_monitor.rb
@@ -41,14 +48,16 @@ files:
 - lib/zeus/server/command_runner.rb
 - lib/zeus/server/file_monitor.rb
 - lib/zeus/server/file_monitor/fsevent.rb
-- lib/zeus/server/forked_process.rb
 - lib/zeus/server/load_tracking.rb
 - lib/zeus/server/process_tree_monitor.rb
 - lib/zeus/server/stage.rb
+- lib/zeus/server/stage/error_state.rb
+- lib/zeus/server/stage/feature_notifier.rb
 - lib/zeus/templates/rails.rb
 - lib/zeus/ui.rb
 - lib/zeus/version.rb
 - spec/cli_spec.rb
+- spec/error_printer_spec.rb
 - spec/integration_spec.rb
 - spec/server/file_monitor/fsevent_spec.rb
 - spec/server/load_tracking_spec.rb
@@ -84,6 +93,7 @@ summary: Zeus is an intelligent preloader for ruby applications. It allows norma
   development tasks to be run in a fraction of a second.
 test_files:
 - spec/cli_spec.rb
+- spec/error_printer_spec.rb
 - spec/integration_spec.rb
 - spec/server/file_monitor/fsevent_spec.rb
 - spec/server/load_tracking_spec.rb

data/lib/zeus/dsl.rb

@@ -1,154 +0,0 @@
-require 'set'
-
-module Zeus
-  module DSL
-
-    class Evaluator
-      def stage(name, &b)
-        stage = DSL::Stage.new(name)
-        stage.root = true
-        stage.instance_eval(&b)
-        stage
-      end
-    end
-
-    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
-
-    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
-
-    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 << DSL::Stage.new(name).tap { |s| s.instance_eval(&b) }
-        self
-      end
-
-      def command(name, *aliases, &b)
-        @stages << DSL::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/forked_process.rb

@@ -1,98 +0,0 @@
-module Zeus
-  class Server
-    # base class for Stage and Acceptor
-    class ForkedProcess
-
-      attr_accessor :name
-      attr_reader :pid
-      def initialize(server)
-        @server = server
-      end
-
-      def notify_feature(feature)
-        @server.__CHILD__stage_has_feature(@name, feature)
-      end
-
-      def descendent_acceptors
-        raise NotImplementedError
-      end
-
-      def process_type
-        raise "NotImplementedError"
-      end
-
-      def notify_started
-        @server.__CHILD__stage_starting_with_pid(@name, Process.pid)
-        Zeus.ui.info("starting #{process_type} `#{@name}`")
-      end
-
-      def notify_terminated
-        # @server.__CHILD__stage_terminating(@name)
-        Zeus.ui.info("killing #{process_type} `#{@name}`")
-      end
-
-      def setup_forked_process(close_parent_sockets)
-        @server.__CHILD__close_parent_sockets if close_parent_sockets
-
-        notify_started
-
-        $0 = "zeus #{process_type}: #{@name}"
-
-        trap("INT") { exit }
-        trap("TERM") {
-          notify_terminated
-          exit
-        }
-
-        defined?(ActiveRecord::Base) and ActiveRecord::Base.clear_all_connections!
-
-      end
-
-      def newly_loaded_features
-        old_features = defined?($previously_loaded_features) ? $previously_loaded_features : []
-        ($LOADED_FEATURES + @server.extra_features) - old_features
-      end
-
-      def runloop!
-        raise NotImplementedError
-      end
-
-      def before_setup
-      end
-
-      def after_setup
-      end
-
-      def notify_new_features
-        new_features = newly_loaded_features()
-        $previously_loaded_features ||= []
-        $previously_loaded_features |= new_features
-        Thread.new {
-          new_features.each { |f| notify_feature(f) }
-        }
-      end
-
-      def after_notify
-      end
-
-      # TODO: This just got really ugly and needs a refactor more than ever.
-      def run(close_parent_sockets = false)
-        @pid = fork {
-          before_setup
-          setup_forked_process(close_parent_sockets)
-
-          Zeus.run_after_fork!
-
-          after_setup
-          notify_new_features
-
-          after_notify
-          runloop!
-        }
-      end
-
-    end
-
-  end
-end
-