mongo_agent 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee39eefc1decdd3c2831ccad3130d9e6f2836ba3
+  data.tar.gz: be4191785f44ef768946182a95b0cca390ad5229
+SHA512:
+  metadata.gz: 8943b3c9a745020ddf853ff1f89d637c0a09a874987d4d8256527cdd143582d75922d5a9170fcbc8fa9dd54c9a8d2e8e882981778ff7b1aa0396660c1242eb49
+  data.tar.gz: 641d079a4dc1a092b9a4d566d2fafb90af2e46d0542b55664ece1f9a2b1c8618a61dc21d773d65106824063ed0f8b02c1422ab9e7a9c417f4396a772c6099cdd

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+gem 'moped'
+gem 'rspec'
+gem 'yard'

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'yard'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']   # optional
+end

data/lib/mongo_agent/agent.rb

@@ -0,0 +1,270 @@
+require 'moped'
+
+module MongoAgent
+
+# @note The license of this source is "MIT Licence"
+
+# MongoAgent::Agent is designed to make it easy to create an agent that works on tasks
+# queued up in a specified queue.  A task is a document in a queue defined in
+# the MONGO_HOST MONGO_DB.  A task must be created by another agent (MongoAgent::Agent,
+# or Human) in the queue.  It must have, at minimum, the following fields:
+#  agent_name: string, name of the agent that should process the task
+#  ready: must be true for an agent to process the task
+# When the agent finds a ready task for its agent_name, it registers itself with the
+# task document by updating its agent_host field to the host that is running the
+# agent, and sets ready to false (meaning it is actually running).  When the agent
+# completes the task, it sets the complete flag to true.  If the agent encounters
+# an error during processing, it can signal failure by setting the errors_encountered
+# field to true at the time its complete flag is updated to true.
+#
+# When an Agent creates a task, it can pass a variety of messages as JSON in the task
+# that can be used by the processing agent.  The processing agent can also pass a
+# variety of messages to other agents when they review the task.  These messages
+# are just fields added to the task Document when it is created or updated by
+# an agent.
+# Any MongoAgent::Agent depends on the following environment variables to configure its
+# MongoDB connection:
+#   MONGO_HOST: host URL for the MongoDB, can be in any form that mongod itself can
+#               use, e.g. host, host:port, etc.
+#   MONGO_DB: the name of the Document store in the MongoDB to use to find its queue.
+#             it will be created if it does not exist
+
+# @author Darin London Copyright 2014
+  class Agent
+
+# This holds the Moped::Session object that can be used to query information from the MongoDB
+#   hosted by the MONGO_HOST environment variable
+# @return [Moped::Session]
+    attr_reader :db
+
+# This holds the log while work! is running
+#    log will be a Hash with the following keys:
+#      tasks_processed: int number of tasks processed (success of failure)
+#      failed_tasks: int number of tasks that have failed
+#    The log is passed to the block that is assigned to process_while (see below)
+# @return [Hash]
+    attr_reader :log
+
+#  This holds a block that will be passed the log as an argument and return true
+#    as long as the agent should continue to process tasks when work! is called,
+#    and false when work! should stop and return.
+#    If not set, the agent will continue to process tasks until it is killed when
+#    work! is called
+#  @return [Block]
+    attr_accessor :process_while
+
+# The name of the agent for which tasks will be taken from the queue
+# @return [String]
+    attr_accessor :name
+
+# The name of the task queue that contains the tasks on which this agent will work.
+# @return [String]
+    attr_accessor :queue
+
+# number of seconds to sleep between each call to process! when running agent.work! or agent.process_while
+# default 5
+    attr_accessor :sleep_between
+
+# create a new MongoAgent::Agent
+# @param attributes [Hash] with name, queue, and optional sleep_between
+# @option attributes [String] name REQUIRED
+# @option attributes [String] queue REQUIRED
+# @option attributes [Int] sleep_between OPTIONAL
+# @raise [MongoAgent::Error] name and queue are missing
+    def initialize(attributes = nil)
+      if attributes.nil?
+        raise MongoAgent::Error, "attributes Hash required with name and queue keys required"
+      end
+      @name = attributes[:name]
+      @queue = attributes[:queue]
+      unless @name && @queue
+        raise MongoAgent::Error, "attributes[:name] and attributes[:queue] are required!"
+      end
+      build_db()
+      if attributes[:sleep_between]
+        @sleep_between = attributes[:sleep_between]
+      else
+        @sleep_between = 5
+      end
+      @log = {
+         tasks_processed: 0,
+         failed_tasks: 0
+      }
+      @process_while = ->(log) { true }
+    end
+
+# If a task for the agent is found that is ready, process! registers itself with the task
+# by setting ready to false, and setting its hostname on the :agent_host field, and then
+# passes the task to the supplied block. This block must return a required boolean field
+# indicating success or failure, and an optional hash of key - value fields that will be
+# updated on the task Document.  Note, the updates are made regardless of the value of
+# success. In fact, the agent can be configured to update different fields based on
+# success or failure.   Also, note that any key, value supported by JSON can be stored
+# in the hash. This allows the agent to communicate any useful information to the task
+# for other agents (MongoAgent::Agent or human) to use. The block must try at all costs
+# to avoid terminating. If an error is encountered, block should return false for the
+# success field to signal that the process failed.  If no errors are encountered block
+# should return true for the success field.
+#
+# @example Exit successfully and sets :complete to true on the task
+#   @agent->process! do |task_hash|
+#     foo = task_hash[:foo]
+#     # do something with foo to perform a task
+#     true
+#   end
+#
+# @example Same, but also sets the 'files_processed' field
+#   @agent->process! { |task_hash|
+#     # ... operation using task_hash for information
+#     [true, {:files_processed => 30}]
+#   }
+#
+# @example Fails, sets :complete to true, and :error_encountered to true
+#   @failure = ->(task_hash){
+#     begin
+#       # ... failing operation using task_hash for information
+#       return true
+#     rescue
+#      return false
+#     end
+#   }
+#
+#   @agent->process!(&@failure)
+#
+# @example Same, but also sets the 'notice' field
+#   @agent->process! do |task_hash|
+#     ...
+#     [false, {:notice => 'There were 10 files left to process!' }]
+#   end
+#
+# @example This agent passes different parameters based on success or failure
+#   $agent->process! { |task_hash|
+#     # ... process and set $success true or false
+#     if $success
+#       [ $success, {:files_processed => 100} ]
+#     else
+#       [ $success, {:files_remaining => 10}]
+#     end
+#   }
+#
+# @param agent_code [Block, Lambda, or Method] Code to process a task
+# @yieldparam Task [Hash]
+# @yieldreturn [Boolean, Hash] success, (optional) hash of fields to update and values to update on the task
+    def process!(&agent_code)
+      (runnable, task) = register()
+      return unless runnable
+      (success, update) = agent_code.call(task)
+      @log[:tasks_processed] += 1
+      if success
+        complete_task(task, update)
+      else
+        fail_task(task, update)
+      end
+      return
+    end
+
+# Iteratively runs process! on the supplied Block, then sleeps :sleep_between
+# between each attempt.  Block should match the specifications of what can
+# be passed to process! (see above).
+#
+# If @process_while is set to a Block, Lambda, or Method, then it is called after
+#  each task is processed, and passed the current @log.  As long as the
+#  Block returns true, work! will continue to process.  work! will stop processing
+#  tasks when the Block returns false.
+#
+# @example process 3 entries and then exit
+#   @agent.process_while = ->(log) {
+#     (log[:tasks_processed] < 3)
+#   }
+#   @agent.work! { |task_hash|
+#     #... do something with task_hash and return true of false just as in process!
+#   }
+#
+# @example process until errors are encountered and then exit
+#   @agent.process_while = ->(log) {
+#     not(log[:errors_encountered])
+#   }
+#   @agent.work! { |task_hash|
+#     #... do something with task_hash and return true of false just as in process!
+#   }
+#   $stderr.puts " #{ @agent.log[:errors_encountered ] } errors were encountered during work."
+# @param agent_code [Block, Lambda, or Method] Code to process a task
+# @yieldparam Task Hash
+# @yieldreturn [Boolean, Hash] success, (optional) hash of fields to update and values to update on the task
+    def work!(&agent_code)
+
+      while (@process_while.call(@log))
+        process!(&agent_code)
+        sleep @sleep_between
+      end
+    end
+
+# get A MONGO_DB[queue] Moped::Query, either for the specified query Hash, or, when
+# query is nil, all that are currently ready for the @name.  This can be used to
+# scan through the tasks on the @queue to perform aggregation tasks:
+# @example collecting information
+#   @agent->get_tasks({
+#      agent_name: @agent->name,
+#      error_encountered: true
+#   }).each do |task|
+#     $stderr.puts "ERROR:\n#{ task.inspect }\n"
+#   end
+#
+# @example update ready to true for tasks that need intervention before they can run
+#   @agent->get_tasks({
+#      agent_name: @agent->name,
+#      waiting_for_information: true
+#   }).each do |task|
+#     task.update('$set' => {ready: true, waiting_form_information: false})
+#   end
+#
+# @param query [Hash] (optional) any query to find tasks
+# @return [Moped::Query]
+    def get_tasks(query = nil)
+      if query.nil?
+        return @db[@queue].find({agent_name: @name, ready: true})
+      else
+        return @db[@queue].find(query)
+      end
+    end
+
+    private
+
+    def register
+      task = get_tasks().first
+      unless task
+        $stderr.puts "there are no ready tasks for #{@name} in queue #{@queue}"
+        return false
+      end
+
+      hostname = Socket.gethostname
+      get_tasks({ _id: task[:_id] }).update('$set' => {ready: false, agent_host: "#{hostname}" })
+      return true, task
+    end
+
+    def complete_task(task, update = nil)
+      if update.nil?
+        update = {}
+      end
+      update[:complete] = true
+      update[:error_encountered] = false
+      get_tasks({ _id: task[:_id] }).update('$set' => update)
+    end
+
+    def fail_task(task, update = nil)
+      @log[:failed_tasks] += 1
+      if update.nil?
+        update = {}
+      end
+      update[:complete] = true
+      update[:error_encountered] = true
+      get_tasks({ _id: task[:_id] }).update('$set' => update)
+    end
+
+    def build_db
+      @db = Moped::Session.new([ ENV['MONGO_HOST'] ])
+      @db.use ENV['MONGO_DB']
+    end
+
+  end #MongoAgent::Agent
+end #MongoAgent

data/lib/mongo_agent/db.rb

@@ -0,0 +1,27 @@
+require 'moped'
+
+module MongoAgent
+
+# MongoAgent::Db is a class that is meant to be extended by MongoAgent classes.  It
+# stores shared code to instantiate and provide access to a MongoDB Document Store and
+# Moped::Session object for use by the extending classes to access their MongoDB Document Store
+#
+# It depends on the following environment variables to configure its MongoDB connect:
+#   MONGO_HOST: host URL for the MongoDB, can be in any form that mongod itself can
+#               use, e.g. host:port, etc.
+#   MONGO_DB: the name of the Document store in the MongoDB to use for all activities
+#             will be created if does not exist
+
+  class Db
+
+# This holds the Moped::Session object that can be used to query information from the MongoDB
+#   hosted by the MONGO_HOST environment variable
+    attr_reader :db
+
+# This is for internal use by SpreadsheetAgent classes that extend SpreadsheetAgent::Db
+    def build_db
+      @db = Moped::Session.new([ ENV['MONGO_HOST'] ])
+      @db.use ENV['MONGO_DB']
+    end
+  end
+end

data/lib/mongo_agent/error.rb

@@ -0,0 +1,8 @@
+module MongoAgent
+
+# MongoAgent::Error is an extension of Error that SpreadsheetAgent classes throw
+# when critical errors are encountered
+  class Error < RuntimeError
+  end
+
+end

data/lib/mongo_agent.rb

@@ -0,0 +1,24 @@
+require 'mongo_agent/agent'
+require 'mongo_agent/error'
+require 'socket'
+
+# @note The license of this source is "MIT Licence"
+# A Distributed Agent System using MongoDB
+#
+# MongoAgent is a framework for creating massively distributed pipelines
+# across many different servers, each using the same MongoDB as a
+# control panel.  It is extensible, and flexible.  It doesnt specify what
+# goals any pipeline should be working towards, or which goals are prerequisites
+# for other goals, but it does provide logic for easily defining these relationships
+# based on your own needs.  It does this by providing a subsumption architecture,
+# whereby many small, highly focused agents are written to perform specific goals,
+# and also know what resources they require to perform them.  Agents can be coded to
+# subsume other agents upon successful completion.  In addition, it is
+# designed from the beginning to support the creation of simple human-computational
+# workflows.
+#
+# MongoAgent requires MongoDB and Moped
+# @version 0.01
+# @author Darin London Copyright 2014
+module MongoAgent
+end

data/spec/mongo_agent_spec.rb

@@ -0,0 +1,353 @@
+require 'mongo_agent'
+require 'moped'
+require 'psych'
+require 'socket'
+
+RSpec.describe "MongoAgent::Agent" do
+  let (:test_agent_name) { 'test_agent' }
+  let (:test_agent_queue) { 'testqueue' }
+  let (:test_agent_sleep_between) { 10 }
+  let (:expected_default_sleep_between) { 5 }
+  let (:test_task_params) {[
+    'foo',
+    'bar',
+    'baz',
+    'bleb'
+  ]}
+  let (:expected_hostname) { Socket.gethostname }
+  before (:each) do
+    @db = Moped::Session.new([ ENV['MONGO_HOST'] ])
+    @db.use ENV['MONGO_DB']
+  end
+
+  after (:each) do
+    @db.drop
+  end
+
+  context "initialization" do
+    it "throws MongoAgent::Error without an attributes Hash" do
+      expect {
+        MongoAgent::Agent.new
+      }.to raise_error { |error|
+        expect(error).to be_a(MongoAgent::Error)
+      }
+    end
+
+    it "throws MongoAgent::Error without attributes[:name]" do
+      expect {
+        MongoAgent::Agent.new({queue: test_agent_queue})
+      }.to raise_error { |error|
+        expect(error).to be_a(MongoAgent::Error)
+      }
+    end
+
+    it 'throws MongoAgent::Error without attributes[:queue]' do
+      expect {
+        MongoAgent::Agent.new({ name: test_agent_name })
+      }.to raise_error { |error|
+        expect(error).to be_a(MongoAgent::Error)
+      }
+    end
+
+    it 'creates MongoAgent::Agent with default sleep_between when provided a name and queue' do
+      expect {
+        @agent = MongoAgent::Agent.new({
+          name: test_agent_name,
+          queue: test_agent_queue
+        })
+      }.to_not raise_error
+      expect(@agent.sleep_between).to eq(expected_default_sleep_between)
+    end
+
+    it 'allows optional attributes[:sleep_between]' do
+      expect {
+        @agent = MongoAgent::Agent.new({
+          name: test_agent_name,
+          queue: test_agent_queue,
+          sleep_between: test_agent_sleep_between
+        })
+      }.to_not raise_error
+      expect(@agent.sleep_between).to eq(test_agent_sleep_between)
+    end
+  end #initialization
+
+  context "process!" do
+    subject {
+      MongoAgent::Agent.new({
+        name: test_agent_name,
+        queue: test_agent_queue
+      })
+    }
+
+    context "with no tasks in queue" do
+      it 'returns without processing any tasks' do
+        called = false
+        subject.process! {
+          called = true
+          true
+        }
+        expect(called).to eq(false)
+        expect(subject.log[:tasks_processed]).to eq(0)
+        expect(subject.log[:failed_tasks]).to eq(0)
+      end
+    end # with no tasks in queue
+
+    context "with no ready tasks in queue" do
+      before(:each) do
+        @db[test_agent_queue].insert( test_task_params.collect{|param|
+          {agent_name: test_agent_name, test_param: param}
+        })
+      end
+
+      it 'return without processing any tasks' do
+        called = false
+        subject.process! {
+          called = true
+          true
+        }
+        expect(called).to eq(false)
+        expect(subject.log[:tasks_processed]).to eq(0)
+        expect(subject.log[:failed_tasks]).to eq(0)
+      end
+    end # with no ready tasks in queue
+
+    context "with ready tasks" do
+      before (:each) do
+        @db[test_agent_queue].insert( test_task_params.collect{|param|
+          {agent_name: test_agent_name, ready: true, test_param: param}
+        })
+      end
+
+      context "success" do
+        context "default" do
+          it 'updates complete, agent_host but not :error_encountered' do
+            called = false
+            processed_param = nil
+            subject.process! { |task|
+              processed_param = task[:test_param]
+              called = true
+              true
+            }
+            expect(processed_param).to be
+            expect(test_task_params.include?(processed_param)).to eq(true)
+            expect(called).to eq(true)
+            expect(subject.log[:tasks_processed]).to eq(1)
+            expect(subject.log[:failed_tasks]).to eq(0)
+            processed_task = @db[test_agent_queue].find(
+            {agent_name: test_agent_name, test_param: processed_param}
+            ).first
+            expect(processed_task).to be
+            expect(processed_task[:complete]).to eq(true)
+            expect(processed_task[:error_encountered]).to eq(false)
+            expect(processed_task[:ready]).to eq(false)
+            expect(processed_task[:agent_host]).to eq(expected_hostname)
+          end
+        end #default
+
+        context "with update" do
+          it 'updates complete, agent_host, and update params, but not error_encountered' do
+            called = false
+            processed_param = nil
+            subject.process! { |task|
+              processed_param = task[:test_param]
+              called = true
+              [true, {test_update: 'updated'}]
+            }
+            expect(processed_param).to be
+            expect(test_task_params.include?(processed_param)).to eq(true)
+            expect(called).to eq(true)
+            expect(subject.log[:tasks_processed]).to eq(1)
+            expect(subject.log[:failed_tasks]).to eq(0)
+            processed_task = @db[test_agent_queue].find(
+            {agent_name: test_agent_name, test_param: processed_param}
+            ).first
+            expect(processed_task).to be
+            expect(processed_task[:complete]).to eq(true)
+            expect(processed_task[:error_encountered]).to eq(false)
+            expect(processed_task[:ready]).to eq(false)
+            expect(processed_task[:agent_host]).to eq(expected_hostname)
+            expect(processed_task[:test_update]).to be
+            expect(processed_task[:test_update]).to eq('updated')
+          end
+        end #with update
+      end #success
+
+      context "failure" do
+        context "default" do
+          it 'updates complete, agent_host, and error_encountered' do
+            called = false
+            processed_param = nil
+            subject.process! { |task|
+              processed_param = task[:test_param]
+              called = true
+              false
+            }
+            expect(processed_param).to be
+            expect(test_task_params.include?(processed_param)).to eq(true)
+            expect(called).to eq(true)
+            expect(subject.log[:tasks_processed]).to eq(1)
+            expect(subject.log[:failed_tasks]).to eq(1)
+            processed_task = @db[test_agent_queue].find(
+            {agent_name: test_agent_name, test_param: processed_param}
+            ).first
+            expect(processed_task).to be
+            expect(processed_task[:complete]).to eq(true)
+            expect(processed_task[:error_encountered]).to eq(true)
+            expect(processed_task[:ready]).to eq(false)
+            expect(processed_task[:agent_host]).to eq(expected_hostname)
+          end
+        end #default
+
+        context "with update" do
+          it 'updates complete, agent_host, update params, and error_encountered' do
+            called = false
+            processed_param = nil
+            subject.process! { |task|
+              processed_param = task[:test_param]
+              called = true
+              [false, {test_update: 'updated'}]
+            }
+            expect(processed_param).to be
+            expect(test_task_params.include?(processed_param)).to eq(true)
+            expect(called).to eq(true)
+            expect(subject.log[:tasks_processed]).to eq(1)
+            expect(subject.log[:failed_tasks]).to eq(1)
+            processed_task = @db[test_agent_queue].find(
+            {agent_name: test_agent_name, test_param: processed_param}
+            ).first
+            expect(processed_task).to be
+            expect(processed_task[:complete]).to eq(true)
+            expect(processed_task[:error_encountered]).to eq(true)
+            expect(processed_task[:ready]).to eq(false)
+            expect(processed_task[:agent_host]).to eq(expected_hostname)
+            expect(processed_task[:test_update]).to be
+            expect(processed_task[:test_update]).to eq('updated')
+          end
+        end #with update
+      end #failure
+    end # with ready tasks
+  end #process!
+
+  context "work!" do
+    subject {
+      MongoAgent::Agent.new({
+        name: test_agent_name,
+        queue: test_agent_queue
+      })
+    }
+
+    context "with no tasks in queue" do
+      before (:each) do
+        @attempts = 0
+        subject.process_while = -> (log) {
+          @attempts += 1
+          ( @attempts < 4 )
+        }
+      end
+
+      it 'returns without processing any tasks' do
+        called = false
+        subject.work! {
+          called = true
+          true
+        }
+        expect(called).to eq(false)
+        expect(subject.log[:tasks_processed]).to eq(0)
+        expect(subject.log[:failed_tasks]).to eq(0)
+      end
+    end # with no ready tasks
+
+    context "with no ready tasks in queue" do
+      before (:each) do
+        @db[test_agent_queue].insert( test_task_params.collect{|param|
+          {agent_name: test_agent_name, test_param: param}
+        })
+        @attempts = 0
+        subject.process_while = -> (log) {
+          @attempts += 1
+          ( @attempts < 4 )
+        }
+      end
+
+      it 'returns without processing any tasks' do
+        called = false
+        subject.work! {
+          called = true
+          true
+        }
+        expect(called).to eq(false)
+        expect(subject.log[:tasks_processed]).to eq(0)
+        expect(subject.log[:failed_tasks]).to eq(0)
+      end
+    end # with no ready tasks in queue
+
+    context "with ready tasks" do
+      before (:each) do
+        @db[test_agent_queue].insert( test_task_params.collect{|param|
+          {agent_name: test_agent_name, ready: true, test_param: param}
+        })
+        subject.process_while = -> (log) {
+          (log[:tasks_processed] < 2)
+        }
+      end
+
+      it "will process! until process_while returns false" do
+        called = 0
+        subject.work! {
+          called += 1
+          true
+        }
+        expect(called).to eq(2)
+        expect(subject.log[:tasks_processed] < 2).to eq(false)
+        expect(subject.log[:tasks_processed]).to eq(2)
+        expect(subject.log[:failed_tasks]).to eq(0)
+      end
+    end # with ready tasks
+  end #work
+
+  context "get_tasks" do
+    let (:error_document) {{
+      agent_name: test_agent_name,
+      test_param: 'finished',
+      agent_host: 'daaedcedddeaaf',
+      test_param: 'failed_entry',
+      complete: true,
+      ready: false,
+      errors_encounterd: true
+    }}
+
+    subject {
+      MongoAgent::Agent.new({
+        name: test_agent_name,
+        queue: test_agent_queue
+      })
+    }
+
+    before (:each) do
+      @db[test_agent_queue].insert( test_task_params.collect{|param|
+        {agent_name: test_agent_name, ready: true, test_param: param}
+      })
+      @db[test_agent_queue].insert(error_document)
+    end
+
+    it "returns all ready tasks in queue by default" do
+      tasks = subject.get_tasks
+      expect(tasks.count).to eq(test_task_params.count)
+      tasks.each do |task|
+        expect(task[:ready]).to eq(true)
+      end
+    end
+
+    it "return only tasks that match the query provided" do
+      tasks = subject.get_tasks({agent_name: test_agent_name, agent_host: error_document[:agent_host]})
+      expect(tasks.count).to eq(1)
+      returned_task = tasks.first
+      returned_task.keys.each do |key|
+        if error_document.keys.include? key
+          expect(returned_task[key]).to eq(error_document[key])
+        end
+      end
+    end
+  end #get_task
+
+end #MongoAgentTest::Agent

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: mongo_agent
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Darin London
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-20 00:00:00.000000000 Z
+dependencies: []
+description: |
+  MongoAgent is a framework for creating distributed pipelines across many
+  different servers. It is extensible, and flexible. It does not specify what goals
+  should be processed.  It simply provides the foundation for using a MongoDB as
+  a messaging queue between many different agents processing tasks defined in the
+  same queue. It is designed from the beginning to support the creation of simple
+  human-computational workflows.
+email: darin.london@duke.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Rakefile
+- lib/mongo_agent.rb
+- lib/mongo_agent/agent.rb
+- lib/mongo_agent/db.rb
+- lib/mongo_agent/error.rb
+- spec/mongo_agent_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/mongo_agent
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: MongoAgent is a framework for creating distributed pipelines across many
+  different servers, each using the same MongoDB as a control panel.
+test_files:
+- spec/mongo_agent_spec.rb
+- spec/spec_helper.rb
+has_rdoc: