rake_server 0.0.1

data/README.rdoc

@@ -0,0 +1,25 @@
+= RakeServer
+
+=== What is it?
+
+RakeServer is a lightweight client/server architecture for running Rake tasks.
+The server is a long-running process that loads tasks from a Rakefile and waits
+for requests to execute tasks. Each time a task is requested, the server forks,
+runs the task, and streams the output from the task back to the client.
+
+When the server is started, it can be given tasks to eager-run; this is
+mainly useful for loading application code into the pre-fork environment.
+
+=== What's the point?
+
+The main intended use case for RakeServer is to provide a means for production
+deployments to run Rake tasks in the background (e.g. via a cron) without
+needing to load the application environment from scratch each time a task is
+executed. It may also be useful for remote invocation of Rake tasks, but that is
+not the main goal.
+
+=== How do I use it?
+
+  $ cd /path/to/my/rails/app
+  $ rake-server environment
+  $ rake-client db:migrate

data/Rakefile

@@ -0,0 +1 @@
+FileList['tasks/**/*.rake'].each { |tasks| load(tasks) }

data/TODO

@@ -0,0 +1,2 @@
+* Start task should block until child has finished starting
+* Fork hooks

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/rake-client

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rake_server')
+
+RakeServer::Client.run(ARGV)

data/bin/rake-server

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rake_server')
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: rake-server [options] [startup-tasks] (start|stop|run|restart)"
+
+  opts.on("-q", "--quiet", "Don't output anything") { |q| options[:quiet] = q }
+  opts.on("-h", "--host [HOST]", "Host to listen on") { |h| options[:host] = h }
+  opts.on("-p", "--port [PORT]", "Port to listen on") { |p| options[:port] = p }
+end.parse!
+
+command = ARGV.shift
+case command
+when 'start'
+  RakeServer::Server.start(ARGV, options)
+when 'run'
+  RakeServer::Server.run(ARGV, options)
+when 'stop'
+  RakeServer::Server.stop(options)
+when 'restart'
+  RakeServer::Server.stop(options)
+  RakeServer::Server.start(options)
+else
+  abort("Unknown command #{command.inspect}")
+end

data/lib/rake_server/client.rb

@@ -0,0 +1,58 @@
+begin
+  require 'eventmachine'
+rescue LoadError => e
+  if require('rubygems') then retry
+  else raise(e)
+  end
+end
+
+module RakeServer
+  class Client < EventMachine::Connection
+    include EventMachine::Protocols::ObjectProtocol
+
+    class <<self
+      def run(args, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        EventMachine.run do
+          EventMachine.connect options[:host], options[:port], self, args
+        end
+      end
+    end
+
+    ENV_PATTERN = /^(\w+)=(.*)$/
+
+    def initialize(args)
+      begin
+        super()
+        @tasks, @env = [], {}
+        args.each do |arg|
+          if match = ENV_PATTERN.match(arg)
+            @env[match[1]] = match[2]
+          else
+            @tasks << arg
+          end
+        end
+      rescue => e
+        STDERR.puts(e.inspect)
+        STDERR.puts(e.backtrace)
+      end
+    end
+
+    def post_init
+      message = Message.new(@tasks, @env)
+      send_object(message)
+    end
+
+    def receive_object(data)
+      if data.nil?
+        unbind
+      else
+        puts(data)
+      end
+    end
+
+    def unbind
+      EventMachine.stop_event_loop
+    end
+  end
+end

data/lib/rake_server/server.rb

@@ -0,0 +1,138 @@
+begin
+  require 'eventmachine'
+  require 'rake'
+rescue LoadError => e
+  if require('rubygems') then retry
+  else raise(e)
+  end
+end
+
+module RakeServer
+  class Server < EventMachine::Connection
+    include EventMachine::Protocols::ObjectProtocol
+
+    class <<self
+      def start(eager_tasks, options = {})
+        pid_file = File.join(pid_dir(options), "rake-server.pid")
+        pid = fork do
+          fork do
+            File.open(pid_file, 'w') { |f| f << Process.pid }
+            run(eager_tasks, options)
+          end
+        end
+        Process.waitpid(pid)
+      end
+
+      def stop(options = {})
+        pid_file = File.join(pid_dir(options), "rake-server.pid")
+        pid = IO.read(pid_file).to_i
+        Process.kill("TERM", pid)
+        FileUtils.rm(pid_file)
+      end
+
+      def run(eager_tasks, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        EventMachine.run do
+          Rake.application.init
+          Rake.application.load_rakefile
+          eager_tasks.each { |task| Rake.application[task].invoke }
+          EventMachine.start_server(options[:host], options[:port], self)
+          unless options[:quiet]
+            puts "rake-server listening on #{options[:host]}:#{options[:port]}"
+          end
+        end
+      end
+
+      def before_fork(&block)
+        @before_fork = block
+      end
+
+      def after_fork(&block)
+        @after_fork = block
+      end
+
+      def run_before_fork
+        @before_fork.call if @before_fork
+      end
+
+      def run_after_fork
+        @after_fork.call if @after_fork
+      end
+
+      private
+
+      def pid_dir(options)
+        pid_dir = options[:pid_dir] || File.join(Dir.pwd, 'tmp', 'pids')
+        unless File.directory?(pid_dir)
+          raise "PID dir #{pid_dir} does not exist -- can't daemonize"
+        end
+        pid_dir
+      end
+    end
+
+    def receive_object(message)
+      begin
+        tasks = message.tasks.map { |task| Rake.application[task.to_sym] }
+        pid = fork_and_run_tasks(tasks, message.env || {})
+      rescue => e
+        send_object("ERR #{e.message}\n")
+        send_object(nil)
+      end
+    end
+
+    private
+
+    def fork_and_run_tasks(tasks, env)
+      input, output = IO.pipe
+      self.class.run_before_fork
+      pid = fork do
+        self.class.run_after_fork
+        env.each_pair do |key, value|
+          ENV[key] = value
+        end
+        input.close
+        STDOUT.reopen(output)
+        STDERR.reopen(output)
+        begin
+          tasks.each { |task| task.invoke }
+        rescue => e
+          STDERR.puts(e.message)
+          STDERR.puts(e.backtrace)
+        ensure
+          output.close
+        end
+      end
+      output.close
+      monitor_tasks(pid, input)
+    end
+
+    def monitor_tasks(pid, input)
+      EventMachine.defer(monitor(pid, input), done(input))
+    end
+
+    def monitor(pid, input)
+      proc do
+        begin
+          until Process.waitpid(pid, Process::WNOHANG)
+            begin
+              until input.eof? || (data = input.read_nonblock(4096)).empty?
+                send_object(data) 
+              end
+            rescue Errno::EAGAIN
+            end
+          end
+          sleep(0.1)
+        rescue => e
+          STDERR.puts(e.inspect)
+        end
+      end
+    end
+
+    def done(input)
+      lambda do
+        send_object(input.read) until input.eof?
+        send_object(nil)
+      end
+    end
+  end
+end

data/lib/rake_server.rb

@@ -0,0 +1,10 @@
+module RakeServer
+  autoload :Server, File.join(File.dirname(__FILE__), 'rake_server', 'server')
+  autoload :Client, File.join(File.dirname(__FILE__), 'rake_server', 'client')
+
+  DEFAULT_OPTIONS = {
+    :host => '127.0.0.1',
+    :port => 7253
+  }
+  Message = Struct.new(:tasks, :env)
+end

data/tasks/gemspec.rake

@@ -0,0 +1,18 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rake_server"
+    gemspec.summary = "Run rake tasks in a client-server architecture"
+    gemspec.description = <<DESC
+RakeServer is a library which allows Rake tasks to be run using client requests
+to a long-running rake server, which can eagerly load required code into memory
+for fast task invocation.
+DESC
+    gemspec.email = "mat@patch.com"
+    gemspec.homepage = "http://github.com/outoftime/rake_server"
+    gemspec.authors = ['Mat Brown', 'Cedric Howe']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  STDERR.puts("Jeweler not available. Install it with `gem install jeweler'")
+end

data/test/Rakefile

@@ -0,0 +1,38 @@
+task :init do
+  system('notify-send "starting up"')
+end
+
+task :shout do
+  system('notify-send "Hey!"')
+end
+
+task :pid do
+  system("notify-send #{Process.pid}")
+end
+
+task :relax do
+  sleep(10)
+end
+
+task :print do
+  puts ENV['MESSAGE']
+end
+
+task :hello do
+  puts "Hello, world!"
+end
+
+task :setup_server do
+  RakeServer::Server.before_fork do
+    `notify-send "#{Process.pid}"`
+  end
+  RakeServer::Server.after_fork do
+    `notify-send "#{Process.pid}"`
+  end
+end
+
+namespace :namespace do
+  task :shout do
+    system('notify-send "Namespace::Hey!"')
+  end
+end

data/tmp/.gitignore

@@ -0,0 +1 @@
+*

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: rake_server
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mat Brown
+- Cedric Howe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-01 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |
+  RakeServer is a library which allows Rake tasks to be run using client requests
+  to a long-running rake server, which can eagerly load required code into memory
+  for fast task invocation.
+
+email: mat@patch.com
+executables: 
+- rake-client
+- rake-server
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- TODO
+files: 
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION
+- bin/rake-client
+- bin/rake-server
+- lib/rake_server.rb
+- lib/rake_server/client.rb
+- lib/rake_server/server.rb
+- tasks/gemspec.rake
+- test/Rakefile
+- tmp/.gitignore
+has_rdoc: true
+homepage: http://github.com/outoftime/rake_server
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Run rake tasks in a client-server architecture
+test_files: []
+