redact 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b4920a30f30707dd2e3dc66e8d42f49e7876aa5
+  data.tar.gz: 8cecbebad2961e3b3b6d80b209a7a9379397f344
+SHA512:
+  metadata.gz: e7009e06e5775b20378c19241b29cccc5f9e551987fded43187b0e48d129b76abc48065939d0b67372ab43e5dc479b70ff563d0f95236a0b30832360de65dc9a
+  data.tar.gz: 460b2a1791d4f36455cd90cba768cf5e97babbb0ec5c6f857a45edd16da9e0ccefdb3085a69099087f212b638ca2228befc71e98e614dc45da2215f765d8b329

data/COPYING

@@ -0,0 +1,10 @@
+Redact is copyright (c) 2014 William Morgan <wmorgan@masanjin.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of Whistlepig nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,94 @@
+Redact is a dependency-based work planner for Redis. It allows you to express
+your work as a set of tasks that are dependent on other tasks, and to execute
+runs across this graph, in such a way that all dependencies for a task are
+guaranteed to be satisfied before the task itself is executed.
+
+It does everything you'd expect from a production planner system:
+* You can make use of arbitrary number of worker processes.
+* You can have arbitrary concurrent runs through the task graph.
+* An application exception causes the task to be retried a fixed number of times.
+* Tasks lost as part of an application crash or Ruby segfault are recoverable.
+
+For debugging purposes, you can use Redact#enqueued_tasks, #in_progress_tasks,
+and #done_tasks to iterate over all tasks, past and present. Note that the
+output from these methods may change rapidly, and that calls are not guaranteed
+to be consisent with each other. The gem provides a simple webserver,
+redact-monitor, for visualizing the current state of the planner.
+
+== Synopsis
+
+  ############ starter.rb #############
+  r = Redis.new
+  p = Redact.new r, namespace: "food/"
+
+  ## set up tasks and dependencies
+  p.add_task :eat, :cook, :lay_table
+  p.add_task :cook, :chop
+  p.add_task :chop, :wash
+  p.add_task :wash, :buy
+  p.add_task :lay_table, :clean_table
+
+  ## publish the graph
+  p.publish_graph!
+
+  ## schedule a run
+  p.do! :eat, "dinner"
+
+  ############ worker.rb #############
+  r = Redis.new
+  p = Redact.new r, namespace: "food/"
+
+  p.each do |task, run_id|
+    puts "#{task} #{run_id}"
+    sleep 1 # do work
+  end
+
+This prints something like:
+
+buy dinner
+wash dinner
+chop dinner
+cook dinner
+clean_table dinner
+lay_table dinner
+eat dinner
+
+You can run multiple copies of worker.rb concurrently to see parallel magic.
+
+== Using Redact
+
+First, some terminology: each node in the graph is a "task". Task depends on
+other tasks. To perform work, you select one of these tasks to be executed;
+this is the "target". An execution of a "target" across the graph is a "run";
+each run has a unique run_id, which you supply. In terms of Ruby objects,
+run_ids are represented as strings, and tasks are always represented as
+symbols.
+
+Adding circular dependencies will result in an error. Specifying a
+previous-used run_id will do something undefined. Otherwise, workers will
+receive tasks in dependency order, and only those tasks which are necessary for
+the execution of a target will be executed.
+
+A run may have key/value parameters. These parameters are supplied to every
+task that is executed as part of that run. These parameters may not be modified
+as part of the run.
+
+You may only have one graph per namespace. However, this graph may have an
+arbitrary number of tasks, and any task may be used as a target.
+
+You must publish the graph (with #publish_graph!) before workers can receive
+it. Worker processes reload the graph before processing every task, so updating
+the graph without restarting worker processes is acceptable. (Of course,
+workers must know how to execute any new tasks you add.)
+
+== Error recovery
+
+Workers that crash due to non-application exceptions (Ruby crashes, bugs in Redact)
+will leave their tasks in the "in processing" queue. You can use
+Redact#in_progress_tasks to iterate over these items; excessively old items are
+probably the result of a process crash.
+
+== Bug reports
+
+Please file bugs here: https://github.com/wmorgan/redact/issues
+Please send comments to: wmorgan-redact-readme@masanjin.net.

data/bin/redact-monitor

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'redis'
+require "redact"
+require 'sinatra/base'
+require 'ostruct'
+
+class Server < Sinatra::Base
+  def initialize redact
+    @redact = redact
+    super
+  end
+
+  get '/' do
+    enqueued = @redact.enqueued_tasks.map  { |t| OpenStruct.new t }
+    in_progress = @redact.in_progress_tasks.map { |t| OpenStruct.new t }
+    done = @redact.done_tasks.map { |t| OpenStruct.new t }
+
+    (enqueued + in_progress + done).each do |x|
+      x.ago = pretty_time_diff((Time.now - x.ts).abs)
+      x.time_in_queue = x.time_waiting ? pretty_time_diff(x.time_waiting.to_i) : ""
+      x.time_in_progress = x.time_processing ? pretty_time_diff(x.time_processing.to_i) : ""
+      x.params = x.params.map { |k, v| "<b>#{k}</b>: #{v}<br/>" }.join
+      x.state_happiness = case x.state
+        when "done"; "success"
+        when "error"; "danger"
+        when "skipped"; "warning"
+        when "in_progress"; x.tries > 0 ? "warning" : ""
+      end
+
+    end
+
+    erb :index, locals: { enqueued: enqueued, in_progress: in_progress, done: done }
+  end
+
+  def pretty_time_diff diff
+    if diff < 60; sprintf("%ds", diff)
+    elsif diff < 60*60; sprintf("%dm", diff / 60)
+    elsif diff < 60*60*24; sprintf("%dh", diff / 60 / 60)
+    else sprintf("%dd", diff / 60 / 60 / 24)
+    end
+  end
+
+  get "/favicon.ico" do
+  end
+end
+Server.set :root, File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+opts, env = Trollop::options do
+  opt :host, "Server host", default: "localhost"
+  opt :port, "Server port", default: 3000
+  opt :rack_handler, "Rack handler", default: "webrick"
+  opt :redis_url, "Redis url", default: "redis://localhost:6379/"
+  opt :namespace, "Redact namespace", type: :string
+end
+
+redis = Redis.new url: opts.redis_url
+begin
+  redis.ping
+rescue Redis::CannotConnectError => e
+  Trollop::die "Can't reach redis host: #{e.message}"
+end
+
+redact = Redact.new redis, namespace: opts.namespace, blocking: false
+server = Server.new redact
+
+app = Rack::Builder.new do
+  use Rack::CommonLogger, $stdout
+  use Rack::ShowExceptions
+  use Rack::Lint
+  run server
+end.to_app
+
+handler = Rack::Handler.get opts.rack_handler.downcase
+
+## OK HERE WE GO!!!
+Signal.trap('INT') { handler.shutdown }
+handler.run app, :Port => opts.port, :Host => opts.host

data/lib/redact.rb

@@ -0,0 +1,316 @@
+require 'tsort'
+require 'socket'
+require 'json'
+require 'redis'
+
+## A distributed, dependency-aware job scheduler for Redis. Like distributed
+## make---you define the dependencies between different parts of your job, and
+## Redact handles the scheduling.
+class Redact
+  include Enumerable
+
+  class TSortHash < Hash
+    include TSort
+    alias tsort_each_node each_key
+    def tsort_each_child node, &block
+      deps = self[node] || []
+      deps.each(&block)
+    end
+  end
+
+  ## Options:
+  ## * +namespace+: prefix for Redis keys, e.g. "redact/"
+  def initialize redis, opts={}
+    @namespace = opts[:namespace]
+    @redis = redis
+    @dag = TSortHash.new
+
+    @queue = [@namespace, "q"].join
+    @processing_list = [@namespace, "processing"].join
+    @done_list = [@namespace, "done"].join
+    @dag_key = [@namespace, "dag"].join
+    @metadata_prefix = [@namespace, "metadata"].join
+    @params_key = [@namespace, "params"].join
+  end
+
+  ## Drop all data and reset the planner.
+  def reset!
+    keys = [@queue, @processing_list, @done_list, @dag_key, @params_key]
+    keys += @redis.keys("#@metadata_prefix/*")
+    keys.each { |k| @redis.del k }
+  end
+
+  class CyclicDependencyError < StandardError; end
+
+  ## Add a task with dependencies. +What+ is the name of a task (either a symbol
+  ## or a string). +Deps+ are any tasks that are dependencies of +what+. +Deps+
+  ## may refer to tasks not already added by #add_task; these will be
+  ## automatically added without dependencies.
+  ##
+  ## Raises a CyclicDependencyError exception if adding these dependencies
+  ## would result in a cyclic dependency.
+  def add_task what, *deps deps = deps.flatten # be nice and allow arrays to be
+    passed in raise ArgumentError, "expecting dependencies to be zero or more
+    task ids" unless deps.all? { |x| x.is_a?(Symbol) } @dag[what] = deps
+
+    @dag.strongly_connected_components.each do |x|
+      raise CyclicDependencyError, "cyclic dependency #{x.inspect}" if x.size != 1
+    end
+  end
+
+  ## Publish the dependency graph. Must be called at least once before #do!.
+  def publish_graph!
+    @redis.set @dag_key, @dag.to_json
+  end
+
+  ## Schedules +target+ for completion among worker processes listening with
+  ## #each. Returns immediately.
+  ##
+  ## Targets scheduled with #do! have their tasks dispatched in generally FIFO
+  ## order; i.e., work for earlier targets will generally be scheduled before
+  ## work for later targets. Of course, the actual completion order of targets
+  ## depends on the completion orders of dependent tasks, the time required for
+  ## these tasks, etc.
+  ##
+  ## You must call #publish_graph! at least once before calling this.
+  ##
+  ## +run_id+ is the unique identifier for this run. Don't reuse these.
+  ##
+  ## +run_params+ are parameters that will be passed to all tasks in this run.
+  ## This value will go through JSON round-trips, so should only contain
+  ## variable types that are expressible with JSON.
+  def do! target, run_id, run_params=nil
+    raise ArgumentError, "you haven't called publish_graph!" unless @redis.exists(@dag_key)
+
+    dag = load_dag
+    target = target.to_s
+    raise ArgumentError, "#{target.inspect} is not a recognized task" unless dag.member?(target)
+
+    @redis.hset @params_key, run_id, run_params.to_json if run_params
+
+    dag.each_strongly_connected_component_from(target) do |tasks|
+      task = tasks.first # all single-element arrays by this point
+      next unless dag[task].nil? || dag[task].empty? # only push tasks without dependencies
+      enqueue_task! task, target, run_id, true
+    end
+  end
+
+  ## Return the total number of outstanding tasks in the queue. Note that this
+  ## is only the number of tasks whose dependencies are satisfied (i.e. those
+  ## only those that are currently ready to be performed). Queue size may
+  ## fluctuate in both directions as targets are built.
+  def size; @redis.llen @queue end
+
+  ## Returns the total number of outstanding tasks currently being processed.
+  def processing_list_size; @redis.llen @processing_list end
+
+  ## Returns the total number of completed tasks we have information about.
+  def done_list_size; @redis.llen @done_list end
+
+  ## Returns information representing the set of tasks currently in the queue.
+  ## The return value is a hash that includes, among other things, these keys:
+  ## +task+: the name of the task
+  ## +run_id+: the run_id of the task
+  ## +target+: the target of the task
+  ## +ts+: the timestamp of queue insertion
+  def enqueued_tasks start_idx=0, end_idx=-1
+    @redis.lrange(@queue, start_idx, end_idx).map { |t| task_summary_for t }
+  end
+
+  ## Returns information representing the set of tasks currently in process by
+  ## worker processes. The return value is a hash that includes keys from
+  ## #enqueued_tasks, plus these keys:
+  ## +worker_id+: the worker_id of the worker processing this task
+  ## +time_waiting+: the approximate number of seconds this task was enqueued for
+  ## +ts+: the timestamp at the start of processing
+  def in_progress_tasks start_idx=0, end_idx=-1
+    @redis.lrange(@processing_list, start_idx, end_idx).map { |t| task_summary_for t }
+  end
+
+  ## Returns information representing the set of tasks that have been
+  ## completed. The return value is a hash that includes keys from
+  ## #in_progress_tasks, plus these keys:
+  ## +worker_id+: the worker_id of the worker processing this task
+  ## +time_waiting+: the approximate number of seconds this task was enqueued for
+  ## +ts+: the timestamp at the end of processing
+  ## +state+: one of "done", "skipped", or "error"
+  ## +error+, +backtrace+: debugging information for tasks in state "error"
+  ## +time_processing+: the approximate number of seconds this task was processed for
+  def done_tasks start_idx=0, end_idx=-1
+    @redis.lrange(@done_list, start_idx, end_idx).map { |t| task_summary_for t }
+  end
+
+  ## Yields tasks from the queue that are ready for execution. Callers should
+  ## then perform the work for those tasks. Any exceptions thrown will result in the
+  ## task being reinserted in the queue and tried at a later point (possibly by another
+  ## process), unless the retry maximum for that task has been exceeded.
+  ##
+  ## This method downloads the task graph as necessary, so live updates of the
+  ## graph are possible without restarting worker processes.
+  ##
+  ## +opts+ are:
+  ## * +blocking+: if true, #each will block until items are available (and will never return)
+  ## * +retries+: how many times an individual job should be retried before resulting in an error state. Default is 2 (so 3 tries total).
+  ## * +worker_id+: the id of this worker process, for debugging. (If nil, will use a reasonably intelligent default.)
+  def each opts={}
+    worker_id = opts[:worker_id] || [Socket.gethostname, $$, $0].join("-")
+    retries = opts[:retries] || 2
+    blocking = opts[:blocking]
+
+    while true
+      ## get the token of the next task to perform
+      meth = blocking ? :brpoplpush : :rpoplpush
+      token = @redis.send meth, @queue, @processing_list
+      break unless token # no more tokens and we're in non-blocking mode
+
+      ## decompose the token
+      task, target, run_id, insertion_time = parse_token token
+
+      ## record that we've seen this
+      set_metadata! task, run_id, worker_id: worker_id, time_waiting: (Time.now - insertion_time).to_i
+
+      ## load the target state. abort if we don't need to do anything
+      target_state = get_state target, run_id
+      if (target_state == :error) || (target_state == :done)
+        #log "skipping #{task}##{run_id} because #{target}##{run_id} is in state #{target_state}"
+        set_metadata! task, run_id, state: :skipped
+        commit! token
+        next
+      end
+
+      ## get any run params
+      params = @redis.hget @params_key, run_id
+      params = JSON.parse(params) if params
+      
+      ## ok, let's finally try to perform the task
+      begin
+        #log "performing #{task}##{run_id}"
+
+        ## the task is now in progress
+        set_metadata! task, run_id, state: :in_progress
+
+        ## do it
+        startt = Time.now
+        yield task.to_sym, run_id, params
+        elapsed = Time.now - startt
+
+        ## update total running time
+        total_time_processing = elapsed + (get_metadata(task, run_id)[:time_processing] || 0).to_f
+        set_metadata! task, run_id, time_processing: total_time_processing
+
+        set_metadata! task, run_id, state: :done
+        enqueue_next_tasks! task, target, run_id
+        commit! token
+      rescue Exception => e
+        num_tries = inc_num_tries! task, run_id
+        if num_tries > retries # we fail
+          set_metadata! target, run_id, state: :error
+          set_metadata! task, run_id, state: :error, error: "(#{e.class}) #{e.message}", backtrace: e.backtrace
+          commit! token
+        else # we'll retry
+          uncommit! token
+        end
+
+        raise
+      end
+    end
+  end
+
+private
+
+  def load_dag
+    dag = JSON.parse @redis.get(@dag_key)
+    dag.inject(TSortHash.new) { |h, (k, v)| h[k] = v; h } # i guess
+  end
+
+  ## tasks are popped from the right, so at_the_end means lpush, otherwise
+  ## rpush.
+  def enqueue_task! task, target, run_id, at_the_end=false
+    set_metadata! task, run_id, state: :in_queue
+    token = make_token task, target, run_id
+    at_the_end ? @redis.lpush(@queue, token) : @redis.rpush(@queue, token)
+  end
+
+  ## move from processing list to done list
+  def commit! token
+    @redis.multi do
+      @redis.lrem @processing_list, 1, token
+      @redis.lpush @done_list, token
+    end
+  end
+
+  ## move from processing list back to queue
+  def uncommit! token
+    @redis.multi do # rewind the rpoplpush
+      @redis.rpush @queue, token
+      @redis.lrem @processing_list, 1, token
+    end
+  end
+
+  ## make pretty thing for debuggin
+  def task_summary_for token
+    task, target, run_id, ts = parse_token token
+    params = @redis.hget @params_key, run_id
+    params = JSON.parse(params) if params
+    get_metadata(task, run_id).merge task: task, run_id: run_id, target: target, insertion_time: ts, params: params
+  end
+
+  ## enqueue all tasks for +target+ that are unblocked by virtue of having
+  ## completed +task+
+  def enqueue_next_tasks! task, target, run_id
+    ## gimme dag
+    dag = load_dag
+
+    ## find all tasks that we block
+    blocked = dag.inject([]) { |a, (k, v)| a << k if v.member?(task.to_s); a }
+
+    ## find all tasks in the path to target
+    in_path_to_target = [] # sigh... ancient interfaces
+    dag.each_strongly_connected_component_from(target) { |x| in_path_to_target << x.first }
+
+    (blocked & in_path_to_target).each do |btask|
+      deps = dag[btask]
+      dep_states = deps.map { |t| get_state t, run_id }
+      if dep_states.all? { |s| s == :done } # we've unblocked it!
+        #log "unblocked task #{btask}##{run_id}"
+        enqueue_task! btask, target, run_id
+      end
+    end
+  end
+
+  def make_token task, target, run_id;
+    [task, target, run_id, Time.now.to_i].to_json
+  end
+
+  def parse_token token
+    task, target, run_id, ts = JSON.parse token
+    [task, target, run_id, Time.at(ts)]
+  end
+
+  def metadata_key_for task, run_id; [@metadata_prefix, task, run_id].join(":") end
+
+  def get_state task, run_id
+    key = metadata_key_for task, run_id
+    (@redis.hget(key, "state") || "unstarted").to_sym
+  end
+
+  def inc_num_tries! task, run_id
+    key = metadata_key_for task, run_id
+    @redis.hincrby key, "tries", 1
+  end
+
+  def set_metadata! task, run_id, metadata
+    metadata.each { |k, v| metadata[k] = v.to_json unless v.is_a?(String) || v.is_a?(Symbol) }
+    metadata[:ts] = Time.now.to_i
+    key = metadata_key_for task, run_id
+    @redis.mapped_hmset key, metadata
+  end
+
+  def get_metadata task, run_id
+    key = metadata_key_for task, run_id
+    md = @redis.hgetall(key).inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+    md[:ts] = Time.at md[:ts].to_i
+    md[:tries] = md[:tries].to_i
+    md
+  end
+end

data/views/index.erb

@@ -0,0 +1,100 @@
+<html>
+<head>
+  <title>Redact status</title>
+  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css">
+  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css">
+  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
+</head>
+
+<body>
+  <h1>In Progress (<%= in_progress.size %>)</h1>
+
+  <div class="table-responsive">
+  <table class="table table-striped table-hover table-condensed">
+    <thead>
+      <tr>
+        <th>Task / Target / Worker</th>
+        <th>Run id</th>
+        <th>Age</th>
+        <th>State</th>
+        <th>Time in queue</th>
+        <th>Params</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% in_progress.each do |t| %>
+        <tr class="<%= t.state_happiness %>">
+          <td><%= t.task %><br/><%= t.target %><br/><%= t.worker_id %></td>
+          <td><%= t.run_id %></td>
+          <td><%= t.ago %></td>
+          <td><%= t.state %></td>
+          <td><%= t.time_in_queue %></td>
+          <td><%= t.params %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  </div>
+
+  <h1>Enqueued (<%= enqueued.size %>)</h1>
+
+  <div class="table-responsive">
+  <table class="table table-striped table-hover table-condensed">
+    <thead>
+      <tr>
+        <th>Task / Target</th>
+        <th>Run id</th>
+        <th>Age</th>
+        <th>State</th>
+        <th>Params</th>
+        <th>Tries</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% enqueued.reverse.each do |t| %>
+        <tr class="<%= t.state_happiness %>">
+          <td><%= t.task %><br/><%= t.target %></td>
+          <td><%= t.run_id %></td>
+          <td><%= t.ago %></td>
+          <td><%= t.state %></td>
+          <td><%= t.params %></td>
+          <td><%= t.tries %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  </div>
+  
+  <h1>Recently completed (<%= done.size %>)</h1>
+
+  <div class="table-responsive">
+  <table class="table table-striped table-hover table-condensed">
+    <thead>
+      <tr>
+        <th>Task / Target / Worker</th>
+        <th>Run id</th>
+        <th>Age</th>
+        <th>State</th>
+        <th>Time in queue</th>
+        <th>Time in progress</th>
+        <th>Params</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% done.each do |t| %>
+        <tr class="<%= t.state_happiness %>">
+          <td><%= t.task %><br/><%= t.target %><br/><%= t.worker_id %></td>
+          <td><%= t.run_id %></td>
+          <td><%= t.ago %></td>
+          <td><%= t.state %></td>
+          <td><%= t.time_in_queue %></td>
+          <td><%= t.time_in_progress %></td>
+          <td><%= t.params %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  </div>
+
+</body>
+</html>

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: redact
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- William Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+description: |
+  Redact is a dependency-based work planner for Redis. It allows you to express
+  your work as a set of tasks that are dependent on other tasks, and to execute
+  runs across this graph, in such a way that all dependencies for a task are
+  guaranteed to be satisfied before the task itself is executed.
+email: wmorgan-redact@masanjin.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- COPYING
+- lib/redact.rb
+- bin/redact-monitor
+- views/index.erb
+homepage: http://gitub.com/wmorgan/redact
+licenses:
+- COPYING
+metadata: {}
+post_install_message: 
+rdoc_options:
+- -c
+- utf8
+- --main
+- README
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A dependency-based work planner for Redis.
+test_files: []