magistrate 0.1.0

data/README.md

@@ -0,0 +1,94 @@
+# Magistrate
+
+## Installation
+
+    gem install magistrate
+
+## Description
+
+Magistrate is a manager for workers that is cluster and network aware.  
+It interacts with a centralized server to get its management and marching orders.
+It's designed to be a process manager that runs entirely in userspace: no root access needed.
+
+## Manual
+
+The magistrate command line tool utilizes the following from the filesystem:
+
+* config/magistrate.yml - The configuration file (override the path with the --config option)
+* tmp/pids - stores the pids of itself and all managed workers
+
+These are meant to coincide with easy running from a Rails app root (so that the worker config can be kept together with the app)
+If you're using capistrano, then the tmp/pids directory is persisted across deploys, so Magistrate will continue to run
+(with an updated config) even after a deploy.
+
+Your user-space cron job should look like this:
+
+*/5 0 0 0 0 magistrate run --config ~/my_app/current/config/magistrate.yml
+
+### What if the server is down?
+
+The magistrate request will time out after 30 seconds and then use its previously stored target_states.yml file
+
+## Command line options
+
+    --config path/to/config.yml
+    
+Sets the config file path.  See example_config.yml for an example config
+
+### run
+
+`magistrate run`
+
+run is the primary command used.  It's intended to be run as a cron job periodically.  Each time it's run it'll:
+
+* Download the target state for each worker from the server
+* Check each worker
+* Try to get it to its target state
+* POST back to the server its state
+
+### list
+
+`magistrate list`
+
+Will return a string like: 
+
+{:test1=>{:state=>:unmonitored, :target_state=>:running}}
+
+This is the status string that is sent to the remote server during a run
+
+### start / stop
+
+`magistrate start WORKER_NAME`
+`magistrate stop WORKER_NAME`
+
+Allows you to manually start/stop a worker process.  This has the side effect of writing the new target_state to the cached target state.  It will
+then continue to use this requested state UNTIL it next gets a different state from the server.
+
+## License
+
+Copyright (C) 2011 by Drew Blas <drew.blas@gmail.com>
+  
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+
+## Attribution
+
+Inspiration and thanks to:
+
+* foreman
+* resque
+* god

data/bin/magistrate

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "magistrate"
+
+require "optparse"
+
+action = :start
+config_file = nil
+
+ARGV.options do |opts|
+  opts.banner = "Usage:  #{File.basename($PROGRAM_NAME)} COMMAND [OPTIONS]"
+  
+  opts.separator "COMMAND: run, list, start WORKER, stop WORKER"
+  
+  opts.separator "Specific Options:"
+  
+  opts.separator "Common Options:"
+  
+  opts.on( "-h", "--help",
+           "Show this message." ) do
+    puts opts
+    exit
+  end
+  
+  opts.on( '-c', '--config FILE', String, 'Specify Config file') do |f|
+    config_file = f
+  end
+  
+  begin
+    opts.parse!
+  rescue
+    puts opts
+    exit
+  end
+end
+
+config_file ||= File.join('config', 'magistrate.yaml')
+
+ARGV[0] ||= 'run'
+
+Magistrate::Supervisor.new(config_file).send(ARGV[0], ARGV[1])

data/lib/magistrate/core_ext.rb

@@ -0,0 +1,13 @@
+class Hash
+  def symbolize_keys!
+      keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+  
+  def recursive_symbolize_keys!
+    symbolize_keys!
+    values.select { |v| v.is_a?(Hash) }.each { |h| h.recursive_symbolize_keys! }
+  end
+end

data/lib/magistrate/process.rb

@@ -0,0 +1,246 @@
+class Magistrate::Process
+
+  attr_reader :name, :daemonize, :start_cmd, :stop_cmd, :pid_file, :working_dir, :env
+  attr_accessor :target_state, :monitored
+
+  def initialize(name, options = {})
+    @name         = name
+    @daemonize    = options[:daemonize]
+    @working_dir  = options[:working_dir]
+    @start_cmd    = options[:start_cmd]
+    
+    if @daemonize
+      @pid_file   = File.join('tmp', 'pids', "#{@name}.pid")
+      @stop_signal = options[:stop_signal] || 'TERM'
+    else
+      @stop_cmd     = options[:end_cmd]
+      @pid_file     = options[:pid_file]
+    end
+    
+    @stop_timeout = 5
+    @start_timeout = 5
+    
+    @env = {}
+
+    @target_state = :unknown
+  end
+  
+  def running?
+  end
+  
+  def state
+    if @target_state == :unmonitored || @target_state == :unknown
+      :unmonitored
+    else
+      if self.alive?
+        :running
+      else
+        :stopped
+      end
+    end
+  end
+  
+  # This is to be called when we first start managing a worker
+  # It will check if the pid exists and if so, is the process responding OK?
+  # It will take action based on the target state
+  def supervise!
+    LOGGER.info("#{@name} supervising.  Is: #{state}.  Target: #{@target_state}")
+    if state != @target_state
+      if @target_state == :running
+        start
+      elsif @target_state == :stopped
+        stop
+      end
+    end
+  end
+  
+  def start
+    LOGGER.info("#{@name} starting")
+    if @daemonize
+      @pid = double_fork(@start_cmd)
+      # TODO: Should check if the pid really exists as we expect
+      write_pid
+    else
+      @pid = single_fork(@start_cmd)
+    end
+    @pid
+  end
+  
+  def stop
+    if @daemonize
+      signal(@stop_signal, pid)
+        
+      # Poll to see if it's dead
+      @stop_timeout.times do
+        begin
+          ::Process.kill(0, pid)
+        rescue Errno::ESRCH
+          # It died. Good.
+          LOGGER.info("#{@name} process stopped")
+          return
+        end
+        
+        sleep 1
+      end
+      
+      signal('KILL', pid)
+      LOGGER.warn("#{@name} still alive after #{@stop_timeout}s; sent SIGKILL")
+    else
+      single_fork(@stop_cmd)
+      ensure_stop
+    end
+  end
+  
+  # single fork self-daemonizing processes
+  # we want to wait for them to finish
+  def single_fork(command)
+    pid = self.spawn(command)
+    status = ::Process.waitpid2(pid, 0)
+    exit_code = status[1] >> 8
+    
+    if exit_code != 0
+      LOGGER.warn("#{@name} command exited with non-zero code = #{exit_code}")
+    end
+    pid
+  end
+  
+  def double_fork(command)
+    pid = nil
+    # double fork daemonized processes
+    # we don't want to wait for them to finish
+    r, w = IO.pipe
+    begin
+      opid = fork do
+        STDOUT.reopen(w)
+        r.close
+        pid = self.spawn(command)
+        puts pid.to_s # send pid back to forker
+      end
+      
+      ::Process.waitpid(opid, 0)
+      w.close
+      pid = r.gets.chomp
+    ensure
+      # make sure the file descriptors get closed no matter what
+      r.close rescue nil
+      w.close rescue nil
+    end
+    
+    pid
+  end
+  
+  # Fork/exec the given command, returns immediately
+  #   +command+ is the String containing the shell command
+  #
+  # Returns nothing
+  def spawn(command)
+    fork do
+      ::Process.setsid
+
+      dir = @working_dir || '/'
+      Dir.chdir dir
+      
+      $0 = command
+      STDIN.reopen "/dev/null"
+      
+      STDOUT.reopen '/dev/null'
+      STDERR.reopen STDOUT
+      
+      # if self.log_cmd
+      #         STDOUT.reopen IO.popen(self.log_cmd, "a") 
+      #       else
+      #         STDOUT.reopen file_in_chroot(self.log), "a"        
+      #       end
+      #       
+      #       if err_log_cmd
+      #         STDERR.reopen IO.popen(err_log_cmd, "a") 
+      #       elsif err_log && (log_cmd || err_log != log)
+      #         STDERR.reopen file_in_chroot(err_log), "a"        
+      #       else
+      #         STDERR.reopen STDOUT
+      #       end
+      
+      # close any other file descriptors
+      3.upto(256){|fd| IO::new(fd).close rescue nil}
+
+      if @env && @env.is_a?(Hash)
+        @env.each do |key, value|
+          ENV[key] = value.to_s
+        end
+      end
+
+      exec command unless command.empty?
+    end
+  end
+  
+  # Ensure that a stop command actually stops the process. Force kill
+  # if necessary.
+  #
+  # Returns nothing
+  def ensure_stop
+    LOGGER.warn("#{@name} ensuring stop...")
+
+    unless self.pid
+      LOGGER.warn("#{@name} stop called but pid is uknown")
+      return
+    end
+    
+    # Poll to see if it's dead
+    @stop_timeout.times do
+      begin
+        signal(0)
+      rescue Errno::ESRCH
+        # It died. Good.
+        return
+      end
+      
+      sleep 1
+    end
+    
+    # last resort
+    signal('KILL')
+    LOGGER.warn("#{@name} still alive after #{@stop_timeout}s; sent SIGKILL")
+  end
+  
+  # Send the given signal to this process.
+  #
+  # Returns nothing
+  def signal(sig, target_pid = nil)
+    target_pid ||= self.pid
+    sig = sig.to_i if sig.to_i != 0
+    LOGGER.info("#{@name} sending signal '#{sig}' to pid #{self.pid}")
+    ::Process.kill(sig, target_pid) rescue nil
+  end
+  
+  # Fetch the PID from pid_file. If the pid_file does not
+  # exist, then use the PID from the last time it was read.
+  # If it has never been read, then return nil.
+  #
+  # Returns Integer(pid) or nil
+  def pid
+    contents = File.read(@pid_file).strip rescue ''
+    real_pid = contents =~ /^\d+$/ ? contents.to_i : nil
+    
+    if real_pid
+      @pid = real_pid
+      real_pid
+    else
+      @pid
+    end
+  end
+  
+  def write_pid
+    File.open(@pid_file, 'w') do |f|
+      f.write @pid
+    end
+  end
+  
+  def alive?
+    if p = self.pid
+      !!::Process.kill(0, p) rescue false
+    else
+      false
+    end
+  end
+
+end

data/lib/magistrate/supervisor.rb

@@ -0,0 +1,159 @@
+require 'rubygems'
+# Ugh, yaml for local serialization and json for over-the-wire serialization sucks.  
+# But YAML doesn't go over the wire well and json doesn't support comments and makes for really bad local config files
+# Almost makes me want to use XML ;)
+require 'yaml'
+require 'json'
+require 'fileutils'
+require 'net/http'
+require 'uri'
+
+module Magistrate
+  class Supervisor    
+    def initialize(config_file)
+      @workers = {}
+      
+      #File.expand_path('~')
+      @pid_path = File.join( 'tmp', 'pids' )
+      
+      FileUtils.mkdir_p(@pid_path) unless File.directory? @pid_path
+      
+      @config = File.open(config_file) { |file| YAML.load(file) }    
+      @config.recursive_symbolize_keys!
+
+      @uri = URI.parse @config[:monitor_url]
+
+      @config[:workers].each do |k,v|
+        @workers[k] = Process.new(k,v)
+      end
+      
+      @loaded_from = nil
+    end
+
+    def run(params = nil)
+      puts "Starting Magistrate [[[#{self.name}]]] talking to [[[#{@config[:monitor_url]}]]]"
+      set_target_states!
+      
+      # Pull in all already-running workers and set their target states
+      @workers.each do |k, worker|
+        worker.supervise!
+      end
+      
+      send_status
+    end
+    
+    # 
+    def start(params = nil)
+      worker = params
+      puts "Starting: #{worker}"
+      @workers[worker.to_sym].supervise!
+      
+      # Save that we've requested this to be started
+    end
+    
+    def stop(params = nil)
+      worker = params
+      puts "Stopping: #{worker}"
+      @workers[worker.to_sym].stop
+      
+      # Save that we've requested this to be stopped
+    end
+    
+    def list(params = nil)
+      set_target_states!
+      
+      require 'pp'
+      pp status
+    end
+    
+    # Returns the actual hash of all workers and their status
+    def status
+      s = {}
+      
+      @workers.each do |k,process|
+        s[k] = {
+          :state => process.state,
+          :target_state => process.target_state
+        }
+      end
+      
+      s
+    end
+    
+    protected
+    
+    # Loads the @target_states from either the remote server or local cache
+    # Then sets all the worker target_states to the loaded values
+    def set_target_states!(local_only = false)
+      local_only ? load_saved_target_states! : load_remote_target_states!
+      
+      if @target_states && @target_states['workers']
+        @target_states['workers'].each do |name, target|
+          name = name.to_sym
+          if @workers[name]
+            @workers[name].target_state = target['target_state'].to_sym if target['target_state']
+          else
+            puts "Worker #{name} not found in local config"
+          end
+        end
+      end
+    end
+    
+    # Gets and sets @target_states from the server
+    # Automatically falls back to the local cache
+    def load_remote_target_states!
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.read_timeout = 30
+      request = Net::HTTP::Get.new(@uri.request_uri + "api/status/#{self.name}")
+
+      response = http.request(request)
+      
+      if response.code == '200'
+        @loaded_from = :server
+        @target_states = JSON.parse(response.body)
+        save_target_states! # The double serialization here might not be best for performance, but will guarantee that the locally stored file is internally consistent
+      else
+        puts "Server responded with error #{response.code} : [[[#{response.body}]]].  Using saved target states..."
+        load_saved_target_states!
+      end
+      
+    rescue StandardError => e
+      puts "Connection to server #{@config[:monitor_url]} failed."
+      puts "Error: #{e}"
+      puts "Using saved target states..."
+      load_saved_target_states!
+    end
+    
+    # Loads the @target_states variable from the cache file
+    def load_saved_target_states!
+      @loaded_from = :file
+      @target_states = File.open(target_states_file) { |file| YAML.load(file) }
+    end
+    
+    def save_target_states!
+      File.open(target_states_file, "w") { |file| YAML.dump(@target_states, file) }
+    end
+    
+    def target_states_file
+      File.join @pid_path, 'target_states.yml'
+    end
+    
+    # Sends the current system status back to the server
+    # Currently only sends basic worker info, but could start sending lots more:
+    # 
+    def send_status
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.read_timeout = 30
+      request = Net::HTTP::Post.new(@uri.request_uri + "api/status/#{self.name}")
+      request.set_form_data({ :status => JSON.generate(status) })
+      response = http.request(request)
+    rescue StandardError => e
+      puts "Sending status to #{@config[:monitor_url]} failed"
+    end
+    
+    # This is the name that the magistrate_monitor will identify us as
+    def name
+      @_name ||= (@config[:supervisor_name_override] || "#{`hostname`.chomp}-#{`whoami`.chomp}").gsub(/[^a-zA-Z0-9\-\_]/, ' ').gsub(/\s+/, '-').downcase
+    end
+  end
+end

data/lib/magistrate/version.rb

@@ -0,0 +1,3 @@
+module Magistrate
+  VERSION = "0.1.0"
+end

data/lib/magistrate.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'magistrate/core_ext'
+require 'magistrate/version'
+require 'magistrate/supervisor'
+require 'magistrate/process'
+
+require 'logger'
+# App wide logging system
+LOGGER = Logger.new(STDOUT)
+
+module Magistrate
+  
+end

data/spec/magistrate/process_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "magistrate/process"
+
+describe "Magistrate::Process" do
+  describe 'Rake-Like Worker' do
+    before(:each) do
+      @process = Magistrate::Process.new(
+        :name => 'rake_like_worker',
+        :daemonize => true,
+        :start_cmd => 'ruby spec/resources/rake_like_worker.rb'
+      )
+      
+      stub(@process).spawn do 
+        raise "Unexpected spawn call made...you don't want your specs actually spawning stuff, right?"
+      end
+    end
+  
+    describe 'state' do
+      it 'should be unmonitored by default' do
+        @process.state.should == :unmonitored
+      end
+      
+      it 'should be unmonitored when unmonitored is the target state' do
+        @process.target_state =  :unmonitored
+        @process.state.should == :unmonitored
+      end
+      
+      it 'should be stopped when target state other that unmonitored' do
+        @process.target_state = :foo
+        @process.state.should == :stopped
+      end
+    end
+    
+    it "should " do
+      true
+    end
+  end
+  
+  describe 'Self-Daemonizing Worker' do
+    
+  end
+end

data/spec/magistrate/supervisor_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "magistrate/supervisor"
+
+describe "Magistrate::Supervisor" do
+  before(:each) do
+    @supervisor = Magistrate::Supervisor.new("spec/resources/example.yml")
+  end
+  
+  it "should initialize correctly" do
+    lambda { Magistrate::Supervisor.new("spec/resources/example.yml") }.should_not raise_error
+  end
+  
+  it "should show basic status for its workers" do
+    @supervisor.status.should == { :daemon_worker=>{:state=>:unmonitored, :target_state=>:unknown}, 
+                                   :rake_like_worker=>{:state=>:unmonitored, :target_state=>:unknown} }
+  end
+  
+#  it 'should'
+end

data/spec/magistrate_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+require "magistrate"
+
+describe Magistrate do
+
+  describe "VERSION" do
+    subject { Magistrate::VERSION }
+    it { should be_a String }
+  end
+
+end

data/spec/resources/example.yml

@@ -0,0 +1,23 @@
+monitor_url: http://localhost
+
+#Normal magistrate reports itself as: `hostname`-`user`
+#supervisor_name_override: some_other_name
+
+workers:
+  # If daemonize is true, then Magistrate will daemonize this process (it doesn't daemonize itself)
+  # Magistrate will track the pid of the underlying process
+  # And will stop it by killing the pid
+  # It will ping the status by sending USR1 signal to the process
+  rake_like_worker:
+    daemonize: true
+    working_dir: /data/app/
+    start_cmd: rake my:task RAILS_ENV=production
+  
+  # If daemonize is false, then Magistrate will use a separate start and stop command
+  # You must also manually specify the pid that this daemonized process creates
+  daemon_worker:
+    daemonize: false
+    working_dir: /data/app/
+    start_cmd: mongrel_rails start -d
+    stop_cmd: mongrel_rails stop
+    pid_file: tmp/pids/mongrel.pid

data/spec/resources/rake_like_worker.rb

@@ -0,0 +1,10 @@
+trap('USR1') {
+  puts 'Doing good'
+}
+
+while true do
+  puts '1'
+  sleep(3)
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require "rubygems"
+require "rspec"
+#require "fakefs/safe"
+#require "fakefs/spec_helpers"
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+def mock_error(subject, message)
+  mock_exit do
+    mock(subject).puts("ERROR: #{message}")
+    yield
+  end
+end
+
+def mock_exit(&block)
+  block.should raise_error(SystemExit)
+end
+# 
+# def load_export_templates_into_fakefs(type)
+#   FakeFS.deactivate!
+#   files = Dir[File.expand_path("../../data/export/#{type}/**", __FILE__)].inject({}) do |hash, file|
+#     hash.update(file => File.read(file))
+#   end
+#   FakeFS.activate!
+#   files.each do |filename, contents|
+#     File.open(filename, "w") do |f|
+#       f.puts contents
+#     end
+#   end
+# end
+# 
+# def example_export_file(filename)
+#   FakeFS.deactivate!
+#   data = File.read(File.expand_path("../resources/export/#{filename}", __FILE__))
+#   FakeFS.activate!
+#   data
+# end
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  #config.include FakeFS::SpecHelpers
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification 
+name: magistrate
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Drew Blas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ronn
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  type: :development
+  version_requirements: *id008
+description: Cluster-based process / worker manager
+email: drew.blas@gmail.com
+executables: 
+- magistrate
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/magistrate
+- lib/magistrate/core_ext.rb
+- lib/magistrate/process.rb
+- lib/magistrate/supervisor.rb
+- lib/magistrate/version.rb
+- lib/magistrate.rb
+- README.md
+- spec/magistrate/process_spec.rb
+- spec/magistrate/supervisor_spec.rb
+- spec/magistrate_spec.rb
+- spec/resources/example.yml
+- spec/resources/rake_like_worker.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/drewblas/magistrate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Cluster-based process / worker manager
+test_files: []
+