zeus 0.4.6 → 0.10.0.pre

data/Gemfile

@@ -2,7 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in zeus.gemspec
 gemspec
-
-gem 'rspec'
-gem 'rake'
-gem 'pry'

data/Rakefile

@@ -1,13 +1,57 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'fileutils'
+require 'pathname'
 
-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
+ROOT_PATH = Pathname.new(File.expand_path("../../", __FILE__))
+RUBYGEM_PATH = Pathname.new(File.expand_path("../", __FILE__))
+
+task build: [:import_externals, :version, :manifest]
+task default: :build
+
+task :import_externals do
+  puts "building rubygem"
+
+  Rake::Task[:clean].invoke
+
+  FileUtils.rm_r(RUBYGEM_PATH + "man") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "build") rescue nil
+
+  # manpages
+  FileUtils.mkdir(RUBYGEM_PATH + "man")
+  FileUtils.cp_r(ROOT_PATH + "man/build", RUBYGEM_PATH + "man")
+
+  # multi-arch binaries
+  FileUtils.cp_r(ROOT_PATH + "build", RUBYGEM_PATH + "build")
+
+  Rake::Task[:manifest].invoke
+  Rake::Task[:build].invoke
+end
+
+task :version do
+  version = File.read('../VERSION').chomp
+  File.open('lib/zeus/version.rb', 'w') { |f| f.puts <<END
+module Zeus
+  VERSION = "#{version}"
+end
+END
+  }
+end
+
+task :manifest do
+  files = `find . -type file | sed 's|^\./||'`.lines.map(&:chomp)
+  exceptions = [
+    /.gitignore$/,
+    /^MANIFEST$/,
+    /^pkg\//,
+  ]
+  files.reject! { |f| exceptions.any? {|ex| f =~ ex }}
+  File.open('MANIFEST', 'w') {|f| f.puts files.join("\n") }
+end
+
+task :clean do
+  FileUtils.rm(RUBYGEM_PATH + "lib/zeus/version.rb") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "man") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "build") rescue nil
 end
 
-task default: :spec

data/bin/zeus

@@ -1,8 +1,16 @@
-#!/usr/bin/env ruby
+platform = `uname -sm`
 
-if defined?(Bundler)
-  puts "\x1b[34mDon't run Zeus with `bundle exec`. It's unnecessarily slow.\x1b[0m"
-end
+exe = case platform
+      when /^Darwin/    ; "zeus-darwin-amd64"
+      when /^Linux.*64/ ; "zeus-linux-amd64"
+      when /^Linux.*/   ; "zeus-linux-386"
+      else
+        puts "Zeus is not supported on your platform."
+        puts "It's not likely to ever be possible on Windows."
+        puts "If you're using another platform that you think should work easily, open an issue at:"
+        puts "https://github.com/burke/zeus/issues"
+        exit 1
+      end
 
-require 'zeus'
-Zeus::CLI.start
+zeusgemdir = File.expand_path("../../", __FILE__)
+exec "#{zeusgemdir}/build/#{exe}", *ARGV

data/examples/zeus.json

@@ -0,0 +1,22 @@
+{
+  "command": "ruby -rzeus/rails -eZeus.go",
+
+  "plan": {
+    "boot": {
+      "default_bundle": {
+        "development_environment": {
+          "prerake": {"rake": []},
+          "runner": ["r"],
+          "console": ["c"],
+          "server": ["s"],
+          "generate": ["g"]
+        },
+        "test_environment": {
+          "testtask": [],
+          "test_helper": {"testrb": []},
+          "spec_helper": {"rspec": []}
+        }
+      }
+    }
+  }
+}

data/ext/inotify-wrapper/extconf.rb

@@ -0,0 +1,24 @@
+if /linux/ =~ RUBY_PLATFORM
+  open("Makefile", "wb") do |f|
+    f.write <<-EOF
+CXX = g++
+CXXFLAGS = -O3 -g -Wall
+
+inotify-wrapper: inotify-wrapper.o
+	$(CXX) $(CXXFLAGS) $< -o $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+install:
+	# do nothing
+    EOF
+  end
+else
+  open("Makefile", "wb") do |f|
+    f.write <<-EOF
+install:
+	# do nothing
+    EOF
+  end
+end

data/ext/inotify-wrapper/inotify-wrapper.cpp

@@ -0,0 +1,86 @@
+#include <map>
+#include <string>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/inotify.h>
+
+#define EVENT_SIZE (sizeof (struct inotify_event))
+#define EVENT_BUF_LEN (1024 * (EVENT_SIZE + 16))
+
+using namespace std;
+
+static int _inotify_fd;
+static map<int, char*> _WatchedFiles;
+static map<char*, bool> _FileIsWatched;
+
+static int inotifyFlags = IN_ATTRIB | IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF;
+
+void maybeAddFileToWatchList(char *file)
+{
+  if (_FileIsWatched[file]) return;
+
+  _FileIsWatched[file] = true;
+  int wd = inotify_add_watch(_inotify_fd, file, inotifyFlags);
+  _WatchedFiles[wd] = file;
+}
+
+void handleStdin()
+{
+  char line[2048];
+  if (fgets(line, sizeof(line), stdin) == NULL) return;
+  line[strlen(line)-1] = 0;
+
+  maybeAddFileToWatchList(line);
+}
+
+void handleInotify()
+{
+  int length;
+  int i = 0;
+  char buffer[EVENT_BUF_LEN];
+  string filename;
+
+  length = read(_inotify_fd, buffer, EVENT_BUF_LEN);
+  if (length < 0) return;
+
+  while (i < length) {
+    struct inotify_event *event = (struct inotify_event *) &buffer[i];
+    printf("%s\n", _WatchedFiles[event->wd]);
+    fflush(stdout);
+
+    i += EVENT_SIZE + event->len;
+  }
+}
+
+void go()
+{
+  fd_set rfds;
+  int retval;
+
+  for (;;) {
+    FD_ZERO(&rfds);
+    FD_SET(0, &rfds);
+    FD_SET(_inotify_fd, &rfds);
+
+    retval = select(_inotify_fd+1, &rfds, NULL, NULL, NULL);
+
+    if (retval == -1) {
+      // perror("select");
+    } else if (retval) {
+      if (FD_ISSET(0, &rfds))           handleStdin();
+      if (FD_ISSET(_inotify_fd, &rfds)) handleInotify();
+    }
+  }
+}
+
+
+int main(int argc, const char *argv[])
+{
+  _inotify_fd = inotify_init();
+  go();
+}

data/lib/zeus.rb

@@ -1,47 +1,135 @@
-require 'zeus/version'
-require 'zeus/ui'
-require 'zeus/plan'
-require 'zeus/server'
-require 'zeus/client'
-require 'zeus/error_printer'
-require 'zeus/cli'
+require 'socket'
+require 'json'
+
+require 'zeus/load_tracking'
 
 module Zeus
-  SOCKET_NAME = '.zeus.sock'
+  class << self
 
-  class ZeusError < StandardError
-    def self.status_code(code)
-      define_method(:status_code) { code }
+    def add_extra_feature(path)
+      $untracked_features ||= []
+      $untracked_features << path
     end
-  end
 
-  def self.ui
-    @ui ||= UI.new
-  end
+    attr_accessor :plan
 
-  def self.ui=(ui)
-    @ui = ui
-  end
+    def report_error_to_master(local, error)
+      str = "R:"
+      str << "#{error.backtrace[0]}: #{error.message} (#{error.class})\n"
+      error.backtrace[1..-1].each do |line|
+        str << "\tfrom #{line}\n"
+      end
+      str << "\0"
+      local.write str
+    end
 
-  def self.after_fork(&b)
-    @after_fork ||= []
-    @after_fork << b
-  end
+    def run_action(socket, identifier)
+      plan.send(identifier)
+      socket.write "R:OK\0"
+    rescue Exception => e
+      report_error_to_master(socket, e)
+    end
 
-  def self.run_after_fork!
-    @after_fork.map(&:call) if @after_fork
-    @after_fork = []
-  end
+    def notify_features(sock, features)
+      features.each do |t|
+        begin
+          sock.write "F:#{t}\0"
+        rescue Errno::ENOBUFS
+          sleep 0.2
+          retry
+        end
+      end
+    end
 
-  def self.thread_with_backtrace_on_error(&b)
-    Thread.new {
-      begin
-        b.call
-      rescue => e
-        ErrorPrinter.new(e).write_to($stdout)
+    def handle_dead_children(sock)
+      # TODO: It would be nice if it were impossible for this
+      # to interfere with the identifer -> IO thing.
+      loop do
+        pid = Process.wait(-1, Process::WNOHANG)
+        break if pid.nil?
+        # sock.send("D:#{pid}")
       end
-    }
-  end
+    rescue Errno::ECHILD
+    end
 
-end
+    def go(identifier=:boot)
+      identifier = identifier.to_sym
+      $0 = "zeus slave: #{identifier}"
+      # okay, so I ahve this FD that I can use to send data to the master.
+      fd = ENV['ZEUS_MASTER_FD'].to_i
+      master = UNIXSocket.for_fd(fd)
+
+      # I need to give the master a way to talk to me exclusively
+      local, remote = UNIXSocket.pair(:DGRAM)
+      master.send_io(remote)
+
+      # Now I need to tell the master about my PID and ID
+      local.write "P:#{Process.pid}:#{identifier}\0"
+
+      # Now we run the action and report its success/fail status to the master.
+      features = features_loaded_by {
+        run_action(local, identifier)
+      }
+
+      # the master wants to know about the files that running the action caused us to load.
+      Thread.new { notify_features(local, features) }
 
+      # We are now 'connected'. From this point, we may receive requests to fork.
+      loop do
+        new_identifier = local.recv(1024)
+        new_identifier.chomp!("\0")
+        if new_identifier =~ /^S:/
+          fork { plan.after_fork ; go(new_identifier.sub(/^S:/,'')) }
+        else
+          fork { plan.after_fork ; command(new_identifier.sub(/^C:/,''), local) }
+        end
+      end
+    end
+
+    def all_features
+      untracked = defined?($untracked_features) ? $untracked_features : []
+      $LOADED_FEATURES + untracked
+    end
+
+    def features_loaded_by(&block)
+      old_features = all_features()
+      yield
+      new_features = all_features() - old_features
+      return new_features
+    end
+
+    def command(identifier, sock)
+      $0 = "zeus runner: #{identifier}"
+      Process.setsid
+
+      local, remote = UNIXSocket.pair(:DGRAM)
+      sock.send_io(remote)
+      remote.close
+      sock.close
+
+      arguments = local.recv(1024)
+      arguments.chomp!("\0")
+
+      pid = fork {
+        plan.after_fork
+        client_terminal = local.recv_io
+        local.write "P:#{Process.pid}:\0"
+        local.close
+
+        $stdin.reopen(client_terminal)
+        $stdout.reopen(client_terminal)
+        $stderr.reopen(client_terminal)
+        ARGV.replace(JSON.parse(arguments))
+
+        plan.send(identifier)
+      }
+
+      Process.wait(pid)
+      code = $?.exitstatus
+
+      local.write "#{code}\0"
+      local.close
+    end
+
+  end
+end

data/lib/zeus/{server/load_tracking.rb → load_tracking.rb}

@@ -2,16 +2,14 @@ module Zeus
   class Server
     class LoadTracking
       class << self
-        attr_accessor :server
 
         def add_feature(file)
-          return unless server
           path = if File.exist?(File.expand_path(file))
             File.expand_path(file)
           else
             find_in_load_path(file)
           end
-          server.add_extra_feature path if path
+          Zeus.add_extra_feature(path) if path
         end
 
         private

data/lib/zeus/rails.rb

@@ -0,0 +1,141 @@
+ROOT_PATH = File.expand_path(Dir.pwd)
+ENV_PATH  = File.expand_path('config/environment',  ROOT_PATH)
+BOOT_PATH = File.expand_path('config/boot',  ROOT_PATH)
+APP_PATH  = File.expand_path('config/application',  ROOT_PATH)
+
+require 'zeus'
+
+module Zeus ; module Rails ; end ; end
+Zeus.plan ||= Zeus::Rails
+
+module Zeus
+  module Rails
+    class << self
+
+      def after_fork
+        reconnect_activerecord
+        restart_girl_friday
+      end
+
+      def boot
+        require BOOT_PATH
+        require 'rails/all'
+      end
+
+      def default_bundle
+        Bundler.require(:default)
+      end
+
+      def development_environment
+        Bundler.require(:development)
+        ::Rails.env = ENV['RAILS_ENV'] = "development"
+        require APP_PATH
+        ::Rails.application.require_environment!
+      end
+
+      def prerake
+        require 'rake'
+        load 'Rakefile'
+      end
+
+      def rake
+        Rake.application.run
+      end
+
+      def generate
+        begin
+          require 'rails/generators'
+          ::Rails.application.load_generators
+        rescue LoadError # Rails 3.0 doesn't require this block to be run, but 3.2+ does
+        end
+        require 'rails/commands/generate'
+      end
+
+      def runner
+        require 'rails/commands/runner'
+      end
+
+      def console
+        require 'rails/commands/console'
+        ::Rails::Console.start(::Rails.application)
+      end
+
+      def server
+        require 'rails/commands/server'
+        server = ::Rails::Server.new
+        Dir.chdir(::Rails.application.root)
+        server.start
+      end
+
+      def test_environment
+        Bundler.require(:test)
+
+        ::Rails.env = ENV['RAILS_ENV'] = 'test'
+        require APP_PATH
+
+        $rails_rake_task = 'yup' # lie to skip eager loading
+        ::Rails.application.require_environment!
+        $rails_rake_task = nil
+        $LOAD_PATH.unshift(ROOT_PATH) unless $LOAD_PATH.include?(ROOT_PATH)
+
+        if Dir.exist?(ROOT_PATH + "/test")
+          test = File.join(ROOT_PATH, 'test')
+          $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
+        end
+
+        if Dir.exist?(ROOT_PATH + "/spec")
+          spec = File.join(ROOT_PATH, 'spec')
+          $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
+        end
+      end
+
+      def test_helper
+        require 'test_helper'
+      end
+
+      def testrb
+        argv = ARGV
+
+        # try to find pattern by line using testrbl
+        if defined?(Testrbl) && argv.size == 1 and argv.first =~ /^\S+:\d+$/
+          file, line = argv.first.split(':')
+          argv = [file, '-n', "/#{Testrbl.send(:pattern_from_file, File.readlines(file), line)}/"]
+          puts "using -n '#{argv[2]}'" # let users copy/paste or adjust the pattern
+        end
+
+        runner = Test::Unit::AutoRunner.new(true)
+        if runner.process_args(argv)
+          exit runner.run
+        else
+          abort runner.options.banner + " tests..."
+        end
+      end
+
+      def spec_helper
+        require 'spec_helper'
+      end
+
+      def rspec
+        exit RSpec::Core::Runner.run(ARGV)
+      end
+
+
+      private
+
+      def restart_girl_friday
+        return unless defined?(GirlFriday::WorkQueue)
+        # The Actor is run in a thread, and threads don't persist post-fork.
+        # We just need to restart each one in the newly-forked process.
+        ObjectSpace.each_object(GirlFriday::WorkQueue) do |obj|
+          obj.send(:start)
+        end
+      end
+
+      def reconnect_activerecord
+        ActiveRecord::Base.clear_all_connections! rescue nil
+        ActiveRecord::Base.establish_connection   rescue nil
+      end
+
+    end
+  end
+end