task_rb 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 194d17f1d017541392f992a1c347ec22c04e76f1
+  data.tar.gz: 713adbbc091faad2991b1a18f0571968890e110a
+SHA512:
+  metadata.gz: 2f4ba9823762f74c376c8b78883f627dab721f67c18edeb1c56f7c89793553f651c364659a12650d5fbf23b886b1ae16659c7de0201dbe148e10a2832ee5e7dd
+  data.tar.gz: b94c11cca50d493cb14fae48802c98467c673da301ca52d510ed2b291d26507a5e83e713bc8f4c083189ed74a0cc4719336cd1b0aad55b1d6e1f2099d1555573

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.1.3
+  - 2.2.0
+  - 2.3.0
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in task.gemspec
+gemspec
+
+gem 'cassava_rb', :git => 'git@github.com:backupify/cassava.git'
+gem 'pyper_rb', :git => 'git@github.com:backupify/pyper.git'
+gem 'values', :git => 'git@github.com:backupify/values.git'
+
+group :development, :test do
+  gem "pry"
+  gem "awesome_print"
+  gem 'm', :git => 'git@github.com:ANorwell/m.git', :branch => 'minitest_5'
+end
+
+group :test do
+  gem 'minitest_should', :git => 'git@github.com:citrus/minitest_should.git'
+  gem "mocha"
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Datto
+
+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
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,154 @@
+# Task
+
+[![Build Status](https://travis-ci.org/backupify/task.svg?branch=master)](https://travis-ci.org/backupify/task)
+
+Task provides a toolbox for generating, tracking and serializing tasks to be performed.
+It is NOT a job queuing framework, a la resque or qless, and does not provide ways to execute tasks
+in a distributed fashion. Rather, Task could be used with such a framework to provide "at-least-once"
+task execution guarantees, or to perform multiple, lightweight tasks within a single job.
+
+An example task lifecycle could be follows:
+
+1. A task is generated by a task generator process
+2. The task is saved to a backing data store, recording that it has been generated and should be completed.
+3. The task is passed, in serialized format, directly from the generating process to another worker process
+or host to complete.
+4. The worker process begins working on the task, and:
+  * The worker process completes the task, marking it as completed in the backing data store.
+
+  OR
+
+  * The worker process fails to complete the task.
+  * A subsequent worker can fetch the task from the backing data store and attempts to complete it.
+
+Task provides mechanisms creating tasks, saving and loading tasks from the backend datastore, and serializing tasks
+for transfer between processes or hosts. However, Task is not a framework, and each step in the lifecycle
+above would be implemented in application code.
+
+Out of the box, Task uses Cassandra as the backing data store, but other backends could be implemented.
+Cassandra provides stronger durability guarantees than some other data stores (for example, Redis). Additionally,
+Cassandra prefers write-heavy workloads. In the workload described above, A task need only be read from the
+datastore if it fails to complete initially. In situations where most tasks complete on the first attempt,
+the majority of datastore operations will be writes. However, because Task does not enforce a usage pattern,
+this could be usage-dependent.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'task_rb', github: 'backupify/task'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### Defining and Creating a Task
+
+To define a task, mix in the Task module:
+
+```ruby
+class FetchFile
+  include Task::Task
+
+  data_attr_reader :external_host
+  data_attr_reader :filename
+end
+```
+
+A task contains a set of data key-value pairs; The `data_attr_reader` helper provides accessors for various expected
+data fields, but is not required.
+
+To build a task, we invoke the build method:
+
+```ruby
+file_task = FetchFile.build(
+  id: 'file1',
+  task_list: 'datto.com',
+  external_host: 'datto.com',
+  filename: 'file1.txt')
+```
+
+Here, the task belongs to the 'datto.com' task list. The ID of the task should be unique across the task list (if one
+is not specified, a UUID will be used). Other provided fields just become part of the data of task; this is just syntactic
+sugar for:
+
+```ruby
+file_task = FetchFile.new(
+  id: 'file1',
+  task_list: 'datto.com',
+  data: { external_host: 'datto.com', filename: 'file1.txt' })
+```
+
+On the task object, the `data_attr_readers` allow access to data fields, so `file_task.data[:external_host]` and
+`file_task.external_host` are equivalent. This is just a convenience, and does not enforce any restrictions on which
+fields can and cannot be placed in the task data.
+
+### Saving and Loading Tasks from the Datastore
+
+To save to the datastore:
+
+```ruby
+file_task.save
+```
+
+If an existing task with the same task list and ID already exists within the backend store, it will be overwritten.
+
+To fetch a particular task (by id) from the datastore:
+
+```ruby
+file_task = Task::Task.find(task_list, id)
+```
+
+To fetch all tasks for a task list from the datastore:
+
+```ruby
+tasks_enumerator = Task::Task.all(task_list)
+```
+
+### Serializing and Deserializing Tasks
+
+To serialize as a hash:
+
+```ruby
+task_hash = my_task.as_hash
+```
+
+To deserialize a task hash to the task that was originally serialized:
+
+```ruby
+my_task = Task::Task.from_hash(task_hash)
+```
+
+Task does not enforce a particular over the wire serialization format.
+
+### Configuring the Datastore
+
+The datastore interface is backed by an adapter. Which adapter is used, and how it is
+constructed, is configurable, by specifying the adapter builder. The specified lambda function
+should take the options passed to the `Interface#new` method, and return the adapter instance:
+
+```ruby
+Task::DataInterface::Interface.adapter_builder = ->(_options) do
+  session = Cassandra.cluster(port: 1234, hosts: ['my_host']).connect('my_tasks')
+  CassandraAdapter.new(client: Cassava::Client.new(session))
+end
+```
+
+This example configures the CassandraAdapter to connect to Cassandra on port 1234 and host 'my_host', and to
+use the keyspace 'my_tasks'. Similarly, a completely separate adapter could be used.
+
+Additionally, data interface instances can be constructed by passing in an adapter, allowing different
+adapters (or adapter configurations) to be used at once.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/backupify/task.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "task"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/task.rb

@@ -0,0 +1,7 @@
+require "task/version"
+require_relative 'task/data_interface'
+require_relative 'task/task'
+require_relative 'task/tasks'
+require_relative 'task/generators'
+
+module Task; end

data/lib/task/data_interface.rb

@@ -0,0 +1,3 @@
+module Task::DataInterface; end
+require_relative 'data_interface/cassandra_adapter'
+require_relative 'data_interface/interface'

data/lib/task/data_interface/cassandra_adapter.rb

@@ -0,0 +1,68 @@
+require 'pyper/all'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module Task::DataInterface
+  class CassandraAdapter
+    attr_reader :client, :tasks_table_name
+
+    # @option opts [Cassava::Client] :client The Cassandra Client to use
+    # @option opts [Symbol] :tasks_table_name The table name of the cassandra table containing the tasks
+    #   Defaults to :tasks
+    def initialize(opts = {})
+      @client = opts[:client]
+      @tasks_table_name = opts[:tasks_table_name] || :tasks
+    end
+
+    # (see Interface)
+    def store(task)
+      pipeline = Pyper::Pipeline.new
+
+      # Serialize the attributes to be stored
+      pipeline << Pyper::Pipes::Model::AttributeSerializer.new
+
+      # Store the serialized attributes in the tasks table
+      pipeline << Pyper::Pipes::Cassandra::Writer.new(tasks_table_name, client)
+      pipeline.push(task.as_hash)
+    end
+
+    # (see Interface)
+    def delete(task_list, task_id)
+      client.delete(:tasks).where(:task_list => task_list, :id => task_id).execute
+    end
+
+    # (see Interface)
+    def all(task_list)
+      read_pipe.push(:task_list => task_list).value
+    end
+
+    def find(task_list, task_id)
+      read_pipe.push(:task_list => task_list, :id => task_id).value.first
+    end
+
+    private
+
+    def read_pipe
+      pipeline = Pyper::Pipeline.new
+
+      # Read items from cassandra, as determined by the args pushed into the pipeline
+      pipeline << Pyper::Pipes::Cassandra::Reader.new(tasks_table_name, client)
+
+      # Deserialize the data field into a hash
+      pipeline << Pyper::Pipes::Model::AttributeDeserializer.new('data' => Hash)
+
+      # Deserialize items into Task objects
+      pipeline << TaskDeserializer
+
+      pipeline
+    end
+
+    class TaskDeserializer
+      def self.pipe(items, status)
+        items.map do |item|
+          Task::Task.from_hash(item.with_indifferent_access)
+        end
+      end
+    end
+  end
+end

data/lib/task/data_interface/interface.rb

@@ -0,0 +1,53 @@
+require 'cassava'
+require 'active_support/core_ext/class/attribute'
+require_relative 'cassandra_adapter'
+
+module Task::DataInterface
+  class Interface
+    attr_reader :adapter
+
+    # The adapter builder function used to initialize the adapter based on the options provided to new.
+    # By default, a CassandraAdapter will be used. For this default adapter builder, the following
+    # arguments are supported:
+    # * :keyspace - the keyspace to use; default is 'tasks'
+    # * any arguments accepted by the #Cassandra.cluster method, including :port and :hosts
+    class_attribute :adapter_builder
+    self.adapter_builder = ->(options) do
+      session = Cassandra.cluster(options).connect(options[:keyspace] || 'tasks')
+      CassandraAdapter.new(client: Cassava::Client.new(session))
+    end
+
+    # @option options [#store,#all,#find,#delete] :adapter adapter to use.
+    #   Otherwise, the configured adapter builder will be used
+    def initialize(options = {})
+      @adapter = options[:adapter] || self.class.adapter_builder.call(options)
+    end
+    # Stores a task in the data store
+    # @param [Task::Task] task
+    def store(task)
+      adapter.store(task)
+    end
+
+    # Returns all tasks for the provided task list
+    # @param [String] task_list
+    # @return [Enumerator::Lazy<Task::Task>]
+    def all(task_list)
+      adapter.all(task_list)
+    end
+
+    # Returns the task with the given id
+    # @param [String] task_list
+    # @param [String] task_id
+    # @return [Task::Task|NilClass]
+    def find(task_list, task_id)
+      adapter.find(task_list, task_id)
+    end
+
+    # Deletes the task with the given id.
+    # @param [String] task_list
+    # @param [String] task_id
+    def delete(task_list, task_id)
+      adapter.delete(task_list, task_id)
+    end
+  end
+end

data/lib/task/generator.rb

@@ -0,0 +1,23 @@
+require 'values'
+
+module Task
+  module Generator
+    include ::Enumerable
+
+    def append(*generators)
+      Generators::CombinedGenerator.new([self] + generators)
+    end
+  end
+
+  module Generators
+    class CombinedGenerator < Value.new(:generators)
+      include Generator
+
+      def each
+        generators.each do |generator|
+          generator.each { |t| yield t }
+        end
+      end
+    end
+  end
+end

data/lib/task/generators.rb

@@ -0,0 +1,2 @@
+require_relative 'generator'
+require_relative 'generators/existing_tasks'

data/lib/task/generators/existing_tasks.rb

@@ -0,0 +1,12 @@
+require 'values'
+require_relative '../generator'
+
+module Task::Generators
+  class ExistingTasks < Value.new(:task_list)
+    include ::Task::Generator
+
+    def each
+      Task::Task.all(task_list).each { |t| yield t }
+    end
+  end
+end

data/lib/task/task.rb

@@ -0,0 +1,162 @@
+require 'virtus'
+require 'active_support/concern'
+require_relative 'data_interface/interface'
+
+module Task
+  # A Task represents a task to be performed. The task can be serialized as JSON to be passed to
+  # other processes to complete, and can be stored in Cassandra as a means of ensuring "at-least-once"
+  # task completion for this task. So, an example lifecycle of a task would be:
+  #   1) A task is generated in a "master" job
+  #   2) The master job saves the task, providing a record that the task was generated.
+  #   3) The master job passes the task to another job to complete the task.
+  #   4) The worker job completes task, removing the record for that task.
+  #   5) If the worker job fails, the task is not completed and so the record for it persists.
+  #   6) A subsequent job can fetch the list of tasks, returning the tasks that failed to complete.
+  #      This job could either serialize them to be completed by other jobs, or complete them directly.
+  #
+  # A task has a unique id, belongs to a task list that group similar tasks together, and has data
+  # associated with it.
+  #
+  # @example Defining a type of Task
+  #   class MyDeleteTask
+  #     include Task::Task
+  #     # This task has the item_id data field, representing the item to delete
+  #     data_attr_reader :item_id
+  #   end
+  #
+  # @example Creating a task
+  #   my_task = MyDeleteTask.build(:id => 'my_id', :task_list => "#{service.id}-delete", :item_id => '123')
+  #
+  # @example Serializing and deserializing a task
+  # # In the process that generated the task
+  # serialized = my_task.as_hash
+  #
+  # # In the process that acts on the hash
+  # my_task_copy = Task::Task.from_hash(serialized)
+  #
+  # @example Saving a task
+  # my_task.save
+  #
+  # @example Fetching a single task that has been saved
+  # Task::DataInterface::Interface.new.find(task_list, task_id)
+  #
+  # @example Fetching all tasks for a task list
+  # Task::DataInterface::Interface.new.all(task_list)
+  #
+  # @example Completing a task, so that it is not longer fetchable
+  # my_task.complete
+  #
+  module Task
+    extend ActiveSupport::Concern
+    include Virtus.module
+
+    attribute :task_list, String
+    attribute :id, String
+    attribute :data, Hash[Symbol => Object]
+
+    module ClassMethods
+      # Instantiate an instance of this Task subclass.
+      # @param options [Hash] Options to instantiate this Task. :task_list and :id are required;
+      #   other arguments will be passed as data to the task.
+      # @option options [String] :task_list
+      # @option options [String] :id
+      def build(options)
+        task_list = options.delete(:task_list)
+        id = options.delete(:id) || SecureRandom.hex
+        new(task_list: task_list, id: id, data: options)
+      end
+
+      # Instantiate an instance of this Task subclass and save it to the datastore.
+      # @param options [Hash] Options to instantiate this Task. :task_list and :id are required;
+      #   other arguments will be passed as data to the task.
+      # @option options [String] :task_list
+      # @option options [String] :id
+      def create(options)
+        task = build(options)
+        task.save
+        task
+      end
+
+      # Defines an attr reader instance method for a field in the data hash.
+      #
+      # @example
+      #    class MyTask
+      #      include Task::Task
+      #      data_attr_reader :my_data_field
+      #    end
+      #
+      # @param attr_name [Symbol] The attr name of the data field which will be used.
+      def data_attr_reader(attr_name)
+        define_method(attr_name) { data[attr_name] }
+      end
+    end
+
+    # Creates a Task object from the provided hash. Generally, this task object should NOT be
+    # constructed manually using this method. Rather, this provides a way to reconstitute a task
+    # that was previously serialized using the #as_hash method.
+    #
+    # @example
+    #   class MyTask
+    #     include Task::Task
+    #     data_attr_reader :my_data_field
+    #   end
+    #   my_task = MyTask.new(:task_list => 'my_task_list', )
+
+    #
+    # @param task_hash [Hash] Should contain the :task_list, :id, :type, and :data fields
+    # @return [Task::Task] The task object.
+    def self.from_hash(task_hash)
+      task_hash = task_hash.dup
+      type = task_hash.delete(:type)
+      type.constantize.new(task_hash)
+    end
+
+    # Returns the task with the given id
+    # @param [String] task_list
+    # @param [String] task_id
+    # @return [Task::Task|NilClass]
+    def self.find(task_list, id)
+      interface.find(task_list, id)
+    end
+
+    # Returns all tasks for the provided task list
+    # @param [String] task_list
+    # @return [Enumerator::Lazy<Task::Task>]
+    def self.all(task_list)
+      interface.all(task_list)
+    end
+
+    # The Data Interface used
+    # @return [Task::DataInterface::Interface]
+    def self.interface
+      DataInterface::Interface.new
+    end
+
+    # Executes this task
+    # @param options [Hash] Options specific to the execution of this task
+    def execute(options = {})
+      raise NotImplementedError.new('execute method not implemented')
+    end
+
+    # Serialized this Task as a hash
+    # @return [Hash]
+    def as_hash
+      attributes.merge(type: self.class.to_s)
+    end
+
+    # Saves this task to the data store.
+    # @return [NilClass]
+    def save
+      Task.interface.store(self)
+      nil
+    end
+
+
+    # Marks this task as complete, removing it from the datastore
+    # @return [NilClass]
+    def complete
+      Task.interface.delete(task_list, id)
+      nil
+    end
+  end
+end

data/lib/task/tasks.rb

@@ -0,0 +1 @@
+require_relative 'tasks/composite_task.rb'

data/lib/task/tasks/composite_task.rb

@@ -0,0 +1,19 @@
+require_relative '../task'
+
+module Task::Tasks
+  class CompositeTask
+    include Task::Task
+
+    data_attr_reader :child_task_list
+
+    # @param opts [Hash] Options to pass to the execute method of each child task
+    # @return [Array] The sequence of return values from each task execution
+    def execute(opts = {})
+      (Task::Task.all(child_task_list).map do |task|
+        task_result = task.execute(opts)
+        task.complete
+        task_result
+       end).force
+    end
+  end
+end

data/lib/task/version.rb

@@ -0,0 +1,3 @@
+module Task
+  VERSION = "0.4.0"
+end

data/task_rb.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'task/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "task_rb"
+  spec.version       = Task::VERSION
+  spec.authors       = ["Arron Norwell"]
+  spec.email         = ["anorwell@datto.com"]
+
+  spec.summary       = %q{Task provides a toolbox for generating, tracking and serializing tasks to be performed.}
+  spec.homepage      = "http://datto.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+
+  spec.add_dependency 'pyper_rb', '~> 1.0'
+  spec.add_dependency 'cassava_rb'
+  spec.add_dependency 'virtus'
+  spec.add_dependency 'values'
+  spec.add_dependency "activesupport"
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: task_rb
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Arron Norwell
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pyper_rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: cassava_rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: values
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- anorwell@datto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/task.rb
+- lib/task/data_interface.rb
+- lib/task/data_interface/cassandra_adapter.rb
+- lib/task/data_interface/interface.rb
+- lib/task/generator.rb
+- lib/task/generators.rb
+- lib/task/generators/existing_tasks.rb
+- lib/task/task.rb
+- lib/task/tasks.rb
+- lib/task/tasks/composite_task.rb
+- lib/task/version.rb
+- task_rb.gemspec
+homepage: http://datto.com
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Task provides a toolbox for generating, tracking and serializing tasks to
+  be performed.
+test_files: []