kindly 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7008dc866f7e27d37c5a69ce8dad35bd6669b42e
-  data.tar.gz: 0aefa9e87d7db75410d5999cee14b742d44cf30d
+  metadata.gz: 0e6a32b5242cdaa718ac34d75b5f0d4c216faa09
+  data.tar.gz: 6b9b08dc1282bd73a313e2841028eecaacc19433
 SHA512:
-  metadata.gz: b97fef9801e31b8337007c1ca996f633b0487bf2590464fc038c6a21269c363a5d15c56b4d6cbf43c63802c92a985597f8f55268637434b2b9c6e3a06e810d57
-  data.tar.gz: 6013ce5a2ffd0180dde7d9b0ece187b268077f406ac8ef2a45c5745b34aaee86c041479171d7d62920d79d2162c722b6eaa1326649fa0149e5d5de08d35cd283
+  metadata.gz: 62eabc59ec779bed01bbb72a4501d5b1492d9968dcfa7a70cd473558ac75863fe2fdf6a72d143ead6a590eac236e667e5b06ec90358444c6570394f6e6d5a87a
+  data.tar.gz: a3447e56fd04edef3ec992f85d362ad651a970b08291907367f18ed49ac1272c9b827a82042a46fd8866228f6d840518362da04127d9b81c627558d391e72388

data/.gitignore

@@ -1,2 +1,3 @@
+.bundle
 Gemfile.lock
 pkg/

data/Rakefile

@@ -1,5 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'kindly'
 
 Rake::TestTask.new do |test|
   test.libs << 'lib' << 'test'
@@ -7,4 +8,34 @@ Rake::TestTask.new do |test|
   test.verbose = true
 end
 
+desc 'Request test_job'
+task :request_test_job do
+  Kindly.request :test_job
+end
+
+desc 'Request test_job_with_input'
+task :request_test_job_with_input do
+  Kindly.request :test_job_with_input, 'hello'
+end
+
+desc 'Request test_job_with_output'
+task :request_test_job_with_output do
+  Kindly.request :test_job_with_output
+end
+
+desc 'Run test_job'
+task :run_test_job do
+  Kindly.run :test_job
+end
+
+desc 'Run test_job_with_input'
+task :run_test_job_with_input do
+  Kindly.run :test_job_with_input
+end
+
+desc 'Run test_job_with_output'
+task :run_test_job_with_output do
+  Kindly.run :test_job_with_output
+end
+
 task :default => :test

data/kindly.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.version       = Kindly::VERSION
   spec.authors       = ['Greg Scott']
   spec.email         = ['i@gregoryjscott.com']
-  spec.summary       = %q{Kindly run migrations of any kind.}
+  spec.summary       = %q{Kindly run jobs of any kind.}
   spec.homepage      = 'https://github.com/gregoryjscott/kindly'
   spec.license       = 'MIT'
 
@@ -19,9 +19,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'mercenary', '~> 0.3'
+  spec.add_runtime_dependency 'aws-sdk', '~> 2'
 
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'mocha', '~> 1.1'
+  spec.add_development_dependency 'minitest', '~> 5.8'
 
 end

data/lib/kindly/db.rb

@@ -0,0 +1,150 @@
+require 'kindly'
+require 'aws-sdk'
+
+module Kindly
+  class DB
+
+    DEFAULTS = {
+      :table_names => {
+        :data => 'job-data',
+        :pending => 'job-pending',
+        :running => 'job-running',
+        :completed => 'job-completed',
+        :failed => 'job-failed'
+      }
+    }
+
+    def initialize(options = {})
+      @config = DEFAULTS.merge(options)
+      @db = Aws::DynamoDB::Client.new(region: 'us-west-2')
+    end
+
+    def user
+      @user ||= Aws::IAM::CurrentUser.new(region: 'us-west-2')
+    end
+
+    def insert_job(job_name, input)
+      item = {
+        'JobId' => SecureRandom.uuid,
+        'JobName' => job_name,
+        'RequestedAt' => Time.now.to_s,
+        'RequestedBy' => user.user_name
+      }
+
+      unless input.empty?
+        data = insert_job_data(input)
+        item['InputDataId'] = data['JobDataId']
+      end
+
+      @db.put_item({ table_name: 'job-pending', item: item })
+      item
+    end
+
+    def insert_job_data(data)
+      item = {
+        'JobDataId' => SecureRandom.uuid,
+        'Data' => data,
+        'CreatedAt' => Time.now.to_s
+      }
+      @db.put_item({ table_name: 'job-data', item: item })
+      item
+    end
+
+    def fetch_job(job_name, job_id)
+      job = Registry.find(job_name)
+      fields = fetch_job_fields(job_id)
+      add_fields_to_job(job, fields)
+
+      if job.fields.has_key?('InputDataId')
+        input = fetch_job_data(job.fields['InputDataId'])
+        job.input = input
+      end
+      job
+    end
+
+    def update_job_status(job, job_status)
+      case job_status
+      when :running
+        delete_job_status(job, :pending)
+      when :completed, :failed
+        delete_job_status(job, :running)
+      else
+        raise "#{new_status} is invalid for job #{job.fields['JobId']}."
+      end
+      insert_job_status(job, job_status)
+    end
+
+    private
+
+    def fetch_job_fields(job_id)
+      response = @db.scan({
+        table_name: @config[:table_names][:pending],
+        select: 'ALL_ATTRIBUTES',
+        filter_expression: "JobId = :job_id",
+        expression_attribute_values: { ":job_id": job_id }
+      })
+
+      raise no_jobs(job_id) if response.items.length == 0
+      raise too_many_jobs(job_id) if response.items.length > 1
+      response.items[0]
+    end
+
+    def fetch_job_data(job_data_id)
+      response = @db.scan({
+        table_name: @config[:table_names][:data],
+        select: 'ALL_ATTRIBUTES',
+        filter_expression: "JobDataId = :job_data_id",
+        expression_attribute_values: { ":job_data_id": job_data_id }
+      })
+
+      raise no_job_data(job_data_id) if response.items.length == 0
+      raise too_many_job_data(job_data_id) if response.items.length > 1
+      response.items[0]['Data']
+    end
+
+    def add_fields_to_job(job, fields)
+      job.instance_eval do
+        def fields
+          @fields
+        end
+
+        def fields=(val)
+          @fields = val
+        end
+      end
+      job.fields = fields
+    end
+
+    def insert_job_status(job, job_status)
+      job.fields['CreatedAt'] = Time.now.to_s
+      @db.put_item({
+        table_name: @config[:table_names][job_status],
+        item: job.fields
+      })
+    end
+
+    def delete_job_status(job, job_status)
+      @db.delete_item({
+        table_name: @config[:table_names][job_status],
+        key: { 'JobId': job.fields['JobId'] }
+      })
+    end
+
+    def no_jobs(job_id)
+      "No pending jobs found for #{job_id}."
+    end
+
+    def too_many_jobs(job_id)
+      "Found too many pending job records for #{job_id}."
+    end
+
+    def no_job_data(job_data_id)
+      "No job data found for #{job_data_id}."
+    end
+
+    def too_many_job_data(job_data_id)
+      "Found too many job data records for #{job_data_id}."
+    end
+
+  end
+end

data/lib/kindly/jobs/do_nothing.rb

@@ -0,0 +1,15 @@
+require 'kindly'
+
+module Kindly
+  module Jobs
+    class DoNothing
+
+      def run
+        puts "Nothing happened."
+      end
+
+    end
+
+    Kindly::Registry.register(:do_nothing, DoNothing.new)
+  end
+end

data/lib/kindly/jobs/test_job.rb

@@ -0,0 +1,15 @@
+require 'kindly'
+
+module Kindly
+  module Jobs
+    class TestJob
+
+      def run
+        puts "fields: #{@fields}"
+      end
+
+    end
+
+    Kindly::Registry.register(:test_job, TestJob.new)
+  end
+end

data/lib/kindly/jobs/test_job_with_input.rb

@@ -0,0 +1,17 @@
+require 'kindly'
+
+module Kindly
+  module Jobs
+    class TestJobWithInput
+
+      attr_accessor :input
+
+      def run
+        puts "input: #{@input}"
+      end
+
+    end
+
+    Kindly::Registry.register(:test_job_with_input, TestJobWithInput.new)
+  end
+end

data/lib/kindly/jobs/test_job_with_output.rb

@@ -0,0 +1,17 @@
+require 'kindly'
+
+module Kindly
+  module Jobs
+    class TestJobWithOutput
+
+      attr_accessor :output
+
+      def run
+        @output = 'goodbye'
+      end
+
+    end
+
+    Kindly::Registry.register(:test_job_with_output, TestJobWithOutput.new)
+  end
+end

data/lib/kindly/queue.rb

@@ -0,0 +1,56 @@
+require 'kindly'
+require 'aws-sdk'
+
+module Kindly
+  class Queue
+
+    def initialize
+      @sqs = Aws::SQS::Client.new(region: 'us-west-2')
+    end
+
+    def add(job_name, job_id)
+      @sqs.send_message({
+        queue_url: queue_url(job_name),
+        message_body: "#{@job_name} has been requested.",
+        message_attributes: {
+          'JobId' => {
+            string_value: job_id,
+            data_type: "String",
+          },
+        },
+      })
+    end
+
+    def pop(job_name)
+      response = @sqs.receive_message({
+        queue_url: queue_url(job_name),
+        message_attribute_names: ['JobId'],
+        max_number_of_messages: 1
+      })
+      raise too_many_messages(job_name) if response.messages.length > 1
+      return nil if response.messages.length == 0
+
+      message = response.messages[0]
+      job_id = message.message_attributes['JobId'].string_value
+
+      @sqs.delete_message({
+        queue_url: queue_url(job_name),
+        receipt_handle: message.receipt_handle
+      })
+
+      job_id
+    end
+
+    private
+
+    def queue_url(job_name)
+      queue = job_name.to_s.gsub('_', '-')
+      "https://sqs.us-west-2.amazonaws.com/529271381487/#{queue}"
+    end
+
+    def too_many_messages(job_name)
+      "Found too many messages for #{job_name}."
+    end
+
+  end
+end

data/lib/kindly/registry.rb

@@ -0,0 +1,30 @@
+require 'kindly'
+
+module Kindly
+  module Registry
+
+    def self.register(job_name, job)
+      @@jobs ||= {}
+      @@jobs[job_name.to_sym] = job
+    end
+
+    def self.unregister(job_name)
+      @@jobs.delete(job_name.to_sym)
+    end
+
+    def self.find(job_name)
+      raise no_job(job_name) unless registered?(job_name)
+      @@jobs[job_name.to_sym]
+    end
+
+    private
+
+    def self.no_job(job_name)
+      "No job registered with name #{job_name}."
+    end
+
+    def self.registered?(job_name)
+      @@jobs.has_key?(job_name.to_sym)
+    end
+  end
+end

data/lib/kindly/requester.rb

@@ -0,0 +1,17 @@
+require 'kindly'
+
+module Kindly
+  class Requester
+
+    def initialize
+      @queue = Queue.new
+      @db = DB.new
+    end
+
+    def request(job_name, input = {})
+      job = @db.insert_job(job_name, input)
+      @queue.add(job_name, job['JobId'])
+    end
+
+  end
+end

data/lib/kindly/runner.rb

@@ -3,28 +3,60 @@ require 'kindly'
 module Kindly
   class Runner
 
-    def initialize(handler)
-      @handler = handler
+    def initialize
+      @queue = Queue.new
+      @db = DB.new
     end
 
-    def run(migration)
-      output = capture_output do
+    def run(job_name)
+      job_id = @queue.pop(job_name)
+      if job_id.nil?
+        puts "No pending requests for #{job_name}."
+        return false
+      end
+
+      job = @db.fetch_job(job_name, job_id)
+      run_job(job)
+
+      job.respond_to?(:output) ? job.output : {}
+    end
+
+    private
+
+    def run_job(job)
+      job.fields['RanBy'] = @db.user.user_name
+      job.fields['StartedAt'] = Time.now.to_s
+      @db.update_job_status(job, :running)
+
+      failed = false
+      log = capture_stdout do
+        puts "#{job.fields['JobId']} started at #{job.fields['StartedAt']}."
         begin
-          migration.running!
-          @handler.run(migration)
-          migration.completed!
-        rescue Exception
+          job.run
+        rescue
+          failed = true
           puts $!, $@
-          migration.failed!
+        end
+        job.fields['FinishedAt'] = Time.now.to_s
+        puts "#{job.fields['JobId']} finished at #{job.fields['FinishedAt']}."
+
+        if job.respond_to? :output
+          data = @db.insert_job_data(job.output)
+          job.fields['OutputDataId'] = data['JobDataId']
         end
       end
+      job.fields['Log'] = log.split("\n")
 
-      write_log_file(migration, output)
+      if failed
+        @db.update_job_status(job, :failed)
+      else
+        @db.update_job_status(job, :completed)
+      end
     end
 
     private
 
-    def capture_output
+    def capture_stdout
       begin
         old_stdout = $stdout
         $stdout = StringIO.new('', 'w')
@@ -35,10 +67,5 @@ module Kindly
       end
     end
 
-    def write_log_file(migration, output)
-      filename = "#{migration.filename}.log"
-      File.open(filename, 'w') { |file| file.write(output) }
-    end
-
   end
 end

data/lib/kindly/version.rb

@@ -1,3 +1,3 @@
 module Kindly
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end

data/lib/kindly.rb

@@ -1,38 +1,23 @@
-require 'kindly/migration'
+require 'kindly/db'
+require 'kindly/queue'
+require 'kindly/registry'
+require 'kindly/requester'
 require 'kindly/runner'
-require 'kindly/handlers'
-require 'kindly/handlers/do_nothing'
 require 'kindly/version'
+require 'kindly/jobs/do_nothing'
+require 'kindly/jobs/test_job'
+require 'kindly/jobs/test_job_with_input'
+require 'kindly/jobs/test_job_with_output'
+require 'aws-sdk'
 
 module Kindly
 
-  def self.run(handler_name, source = '_migrations')
-    @@source = source
-    puts "Kindly run #{handler_name} in #{source} directory."
-
-    handler = Handlers.find(handler_name)
-    runner = Runner.new(handler)
-    migrations = find_migrations(handler.ext)
-
-    puts "No migrations found for #{handler_name} handler." if migrations.empty?
-    migrations.each { |migration| runner.run(migration) }
-  end
-
-  def self.source
-    @@source
-  end
-
-  private
-
-  def self.find_migrations(ext)
-    filenames = Dir[File.join(source, 'pending', "*.#{ext}")]
-    build_migrations(filenames)
+  def self.run(job_name)
+    Runner.new.run(job_name)
   end
 
-  def self.build_migrations(filenames)
-    migrations = []
-    filenames.each { |filename| migrations << Migration.new(filename) }
-    migrations
+  def self.request(job_name, input = {})
+    Requester.new.request(job_name, input)
   end
 
 end

data/test/fixtures/jobs/fail.rb

@@ -0,0 +1,15 @@
+require 'kindly'
+
+module Fixtures
+  module Jobs
+    class Fail
+
+      def run
+        raise "This handler fails every time."
+      end
+
+    end
+
+    Kindly::Registry.register(:fail, Fail.new)
+  end
+end

data/test/kindly/migration_test.rb

@@ -1,108 +1,114 @@
-require 'kindly'
-require 'minitest/autorun'
-require 'mocha/mini_test'
-
-describe 'Migration' do
-
-  let(:filename) { File.join('test', 'fixtures', 'pending', 'one.json') }
-  let(:migration) { migration = Kindly::Migration.new(filename) }
-
-  before(:each) do
-    Kindly.stubs(:source).returns(File.join('test', 'fixtures'))
-  end
-
-  describe 'logs' do
-
-    before(:each) { migration.stubs(:move) }
-
-    it 'when running' do
-      output = capture_output { migration.running! }
-      assert running?(output)
-    end
-
-    it 'when completed' do
-      output = capture_output { migration.completed! }
-      assert completed?(output)
-    end
-
-    it 'when failed' do
-      output = capture_output { migration.failed! }
-      assert failed?(output)
-    end
-
-    def running?(output)
-      output.include?("#{filename} running")
-    end
-
-    def completed?(output)
-      output.include?("#{filename} completed") && !failed?(output)
-    end
-
-    def failed?(output)
-      output.include?("#{filename} failed") && !completed?(output)
-    end
-
-  end
-
-  describe 'moves files' do
-
-    let(:source) { File.join('test', 'fixtures') }
-    let(:tmp_dir) { File.join(source, 'tmp') }
-
-    before(:each) do
-      FileUtils.mkdir(tmp_dir) unless Dir.exist?(tmp_dir)
-      Dir[File.join(source, 'pending', '*.json')].each do |file|
-        FileUtils.cp(file, tmp_dir)
-      end
-    end
-
-    after(:each) do
-      restore_pending
-      remove(File.join(source, 'running'))
-      remove(File.join(source, 'completed'))
-      remove(File.join(source, 'failed'))
-      remove(tmp_dir)
-    end
-
-    it 'when running' do
-      capture_output { migration.running! }
-      assert File.exist?(File.join(source, 'running', File.basename(filename)))
-    end
-
-    it 'when completed' do
-      capture_output { migration.completed! }
-      assert File.exist?(File.join(source, 'completed', File.basename(filename)))
-    end
-
-    it 'when failed' do
-      capture_output { migration.failed! }
-      assert File.exist?(File.join(source, 'failed', File.basename(filename)))
-    end
-
-    def restore_pending
-      pending_dir = File.join(source, 'pending')
-      FileUtils.rm_r(pending_dir)
-      FileUtils.mkdir(pending_dir)
-      Dir[File.join(tmp_dir, '*.json')].each do |file|
-        FileUtils.cp(file, pending_dir)
-      end
-    end
-
-    def remove(dir)
-      FileUtils.rm_r(dir) if Dir.exist?(dir)
-    end
-
-  end
-
-  def capture_output
-    begin
-      old_stdout = $stdout
-      $stdout = StringIO.new('', 'w')
-      yield
-      $stdout.string
-    ensure
-      $stdout = old_stdout
-    end
-  end
-
-end
+# require 'kindly'
+# require 'minitest/autorun'
+# require 'mocha/mini_test'
+#
+# describe 'Job' do
+#   let(:source) { File.join('test', 'fixtures', 'jobs', 'read_json') }
+#   let(:config) {
+#     {
+#       :source => source,
+#       :pending => File.join(source, 'pending'),
+#       :running => File.join(source, 'running'),
+#       :completed => File.join(source, 'completed'),
+#       :failed => File.join(source, 'failed')
+#     }
+#   }
+#   let(:filename) { File.join(config[:pending], 'one.json') }
+#   let(:job) { job = Kindly::Job.new(filename) }
+#
+#   before(:each) do
+#     Kindly.stubs(:config).returns(config)
+#   end
+#
+#   describe 'logs' do
+#     before(:each) { job.stubs(:move) }
+#
+#     it 'when running' do
+#       output = capture_output { job.running! }
+#       assert running?(output)
+#     end
+#
+#     it 'when completed' do
+#       output = capture_output { job.completed! }
+#       assert completed?(output)
+#     end
+#
+#     it 'when failed' do
+#       output = capture_output { job.failed! }
+#       assert failed?(output)
+#     end
+#
+#     def running?(output)
+#       output.include?("#{filename} running")
+#     end
+#
+#     def completed?(output)
+#       output.include?("#{filename} completed") && !failed?(output)
+#     end
+#
+#     def failed?(output)
+#       output.include?("#{filename} failed") && !completed?(output)
+#     end
+#
+#   end
+#
+#   describe 'moves files' do
+#
+#     let(:tmp_dir) { File.join(source, 'tmp') }
+#
+#     before(:each) do
+#       FileUtils.mkdir(tmp_dir) unless Dir.exist?(tmp_dir)
+#       Dir[File.join(source, 'pending', '*.json')].each do |file|
+#         FileUtils.cp(file, tmp_dir)
+#       end
+#     end
+#
+#     after(:each) do
+#       restore_pending
+#       remove(config[:running])
+#       remove(config[:completed])
+#       remove(config[:failed])
+#       remove(tmp_dir)
+#     end
+#
+#     it 'when running' do
+#       capture_output { job.running! }
+#       assert File.exist?(File.join(config[:running], File.basename(filename)))
+#     end
+#
+#     it 'when completed' do
+#       capture_output { job.completed! }
+#       assert File.exist?(File.join(config[:completed], File.basename(filename)))
+#     end
+#
+#     it 'when failed' do
+#       capture_output { job.failed! }
+#       assert File.exist?(File.join(config[:failed], File.basename(filename)))
+#     end
+#
+#     def restore_pending
+#       FileUtils.rm_r(config[:pending])
+#       FileUtils.mkdir(config[:pending])
+#       Dir[File.join(tmp_dir, '*.json')].each do |file|
+#         FileUtils.cp(file, config[:pending])
+#       end
+#     end
+#
+#     def remove(dir)
+#       FileUtils.rm_r(dir) if Dir.exist?(dir)
+#     end
+#
+#   end
+#
+#   def capture_output
+#     begin
+#       old_stdout = $stdout
+#       $stdout = StringIO.new('', 'w')
+#       yield
+#       $stdout.string
+#     ensure
+#       $stdout = old_stdout
+#     end
+#   end
+#
+# end

data/test/kindly/registry_test.rb

@@ -0,0 +1,24 @@
+require 'kindly'
+require 'minitest/autorun'
+
+describe 'Kindly::Registry' do
+
+  let(:registry) { Kindly::Registry }
+  let(:do_nothing) { Kindly::Jobs::DoNothing.new }
+
+  it 'throws if job is not registered' do
+    assert_raises(RuntimeError) { registry.find(:missing) }
+  end
+
+  it 'allows job to be registered' do
+    registry.register :do_nothing, do_nothing
+    assert registry.find(:do_nothing) == do_nothing
+  end
+
+  it 'allows job to be unregistered' do
+    registry.register :do_nothing, do_nothing
+    registry.unregister :do_nothing
+    assert_raises(RuntimeError) { registry.find(:do_nothing) }
+  end
+
+end

data/test/kindly/runner_test.rb

@@ -1,44 +1,77 @@
 require 'kindly'
 require 'minitest/autorun'
 require 'mocha/mini_test'
-require 'fileutils'
+require 'fixtures/jobs/fail'
 
-describe 'Runner' do
 
-  let(:filename) { File.join('test', 'fixtures', 'pending', 'one.json') }
-  let(:migration) { migration = Kindly::Migration.new(filename) }
-  let(:runner) { Kindly::Runner.new(Kindly::Handlers::DoNothing.new) }
+describe 'Kindly::Runner' do
 
-  before(:each) do
-    migration.stubs(:move)
-  end
+  # let(:job) { mock() }
+  #
+  # before(:each) do
+  #   job.stubs(:fetch)
+  #   job.stubs(:data)
+  #   job.stubs(:running!)
+  # end
 
-  after(:each) do
-    logfile = "#{filename}.log"
-    FileUtils.rm(logfile) if File.exist?(logfile)
-  end
-
-  it 'sets migration to running if loads succeeds' do
-    migration.expects(:running!).once
-    runner.run(migration)
-  end
-
-  it 'sets migration to loading even if load fails' do
-    migration.stubs(:load).raises
-    migration.expects(:running!).once
-    runner.run(migration)
-  end
-
-  it 'sets migration to completed if Runner succeeds' do
-    migration.expects(:completed!).once
-    migration.expects(:failed!).never
-    runner.run(migration)
-  end
-
-  it 'writes log file' do
-    runner.run(migration)
-    expected_log_file = "#{migration.filename}.log"
-    assert File.exist?(expected_log_file)
-  end
+  # it 'returns if the job is a success' do
+  #   job.stubs(:completed!)
+  #   result = Kindly::Runner.new(:do_nothing).run(job)
+  #   assert result[:success]
+  # end
+  #
+  # it 'returns if the job is not a success' do
+  #   job.stubs(:failed!)
+  #   result = Kindly::Runner.new(:fail).run(job)
+  #   refute result[:success]
+  # end
 
 end
+
+# require 'kindly'
+# require 'minitest/autorun'
+# require 'mocha/mini_test'
+# require 'fileutils'
+# require 'fixtures/handlers/fail'
+#
+# describe 'Runner' do
+#
+#   let(:read_json) { File.join('test', 'fixtures', 'jobs', 'read_json') }
+#   let(:filename) { File.join(read_json, 'pending', 'one.json') }
+#   let(:job) { job = Kindly::Job.new(filename) }
+#   let(:runner) { Kindly::Runner.new(Kindly::Handlers::DoNothing.new) }
+#   let(:runner_that_fails) { Kindly::Runner.new(Fixtures::Handlers::Fail.new) }
+#
+#   before(:each) do
+#     job.stubs(:move)
+#   end
+#
+#   after(:each) do
+#     logfile = "#{filename}.log"
+#     FileUtils.rm(logfile) if File.exist?(logfile)
+#   end
+#
+#   it 'sets job to running' do
+#     job.expects(:running!).once
+#     runner.run(job)
+#   end
+#
+#   it 'sets job to completed if job succeeds' do
+#     job.expects(:completed!).once
+#     job.expects(:failed!).never
+#     runner.run(job)
+#   end
+#
+#   it 'sets job to failed if job fails' do
+#     job.expects(:completed!).never
+#     job.expects(:failed!).once
+#     runner_that_fails.run(job)
+#   end
+#
+#   it 'writes log file' do
+#     runner.run(job)
+#     expected_log_file = "#{job.filename}.log"
+#     assert File.exist?(expected_log_file)
+#   end
+#
+# end

data/test/kindly_test.rb

@@ -1,27 +1,60 @@
 require 'kindly'
 require 'minitest/autorun'
-require 'mocha/mini_test'
+# require 'mocha/mini_test'
 
 describe 'Kindly' do
 
-  it 'runs given handler name' do
-    Kindly.stubs(:source).returns(File.join('test', 'fixtures'))
-    Kindly::Runner.any_instance.expects(:run).twice
-    capture_output { Kindly.run(:do_nothing) }
-  end
+  # it 'works' do
+  #   Kindly.request :test_job
+  # end
 
-  it 'defaults source to _migrations' do
-    Kindly::Runner.any_instance.stubs(:run)
-    capture_output { Kindly.run(:do_nothing) }
-    assert Kindly.source == '_migrations'
-  end
+  # it 'returns true if message was handled' do
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   Kindly::Queue.any_instance.stubs(:pop).returns([1, { hello: 'world' }])
+  #   Kindly::Queue.any_instance.stubs(:delete)
+  #   assert Kindly.run(:do_nothing)
+  # end
+  #
+  # it 'returns false if message was not found' do
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   Kindly::Queue.any_instance.stubs(:pop).returns([nil, nil])
+  #   Kindly::Queue.any_instance.stubs(:delete)
+  #   capture_output { refute Kindly.run(:do_nothing) }
+  # end
 
-  it 'allows source to be overridden' do
-    Kindly::Runner.any_instance.stubs(:run)
-    fixtures = File.join('test', 'fixtures')
-    capture_output { Kindly.run(:do_nothing, fixtures) }
-    assert Kindly.source == fixtures
-  end
+  # let(:read_json) { File.join('test', 'fixtures', 'jobs', 'read_json') }
+  # let(:pending) { File.join(read_json, 'pending') }
+  #
+  # it 'runs given handler name' do
+  #   Kindly.stubs(:config).returns(:source => read_json)
+  #   Kindly::Runner.any_instance.expects(:run).twice
+  #   capture_output { Kindly.run(:do_nothing) }
+  # end
+  #
+  # it 'defaults source to _jobs' do
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   capture_output { Kindly.run(:do_nothing) }
+  #   assert Kindly.config[:source] == '_jobs'
+  # end
+  #
+  # it 'allows source to be overridden' do
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   capture_output { Kindly.run(:do_nothing, :source => read_json) }
+  #   assert Kindly.config[:source] == read_json
+  # end
+  #
+  # it 'defaults pending to _jobs/pending' do
+  #   expected = File.join('_jobs', 'pending')
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   capture_output { Kindly.run(:do_nothing) }
+  #   assert Kindly.config[:pending] == expected
+  # end
+  #
+  # it 'allows pending to be overridden' do
+  #   Kindly::Runner.any_instance.stubs(:run)
+  #   capture_output { Kindly.run(:do_nothing, :pending => pending) }
+  #   assert_equal pending, Kindly.config[:pending]
+  # end
 
   def capture_output
     begin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kindly
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Greg Scott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mercenary
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,11 +80,24 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
 description: 
 email:
 - i@gregoryjscott.com
-executables:
-- kindly
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -79,18 +106,21 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- bin/kindly
 - kindly.gemspec
 - lib/kindly.rb
-- lib/kindly/handlers.rb
-- lib/kindly/handlers/do_nothing.rb
-- lib/kindly/migration.rb
+- lib/kindly/db.rb
+- lib/kindly/jobs/do_nothing.rb
+- lib/kindly/jobs/test_job.rb
+- lib/kindly/jobs/test_job_with_input.rb
+- lib/kindly/jobs/test_job_with_output.rb
+- lib/kindly/queue.rb
+- lib/kindly/registry.rb
+- lib/kindly/requester.rb
 - lib/kindly/runner.rb
 - lib/kindly/version.rb
-- test/fixtures/pending/one.json
-- test/fixtures/pending/two.json
-- test/kindly/handlers_test.rb
+- test/fixtures/jobs/fail.rb
 - test/kindly/migration_test.rb
+- test/kindly/registry_test.rb
 - test/kindly/runner_test.rb
 - test/kindly_test.rb
 homepage: https://github.com/gregoryjscott/kindly
@@ -113,14 +143,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Kindly run migrations of any kind.
+summary: Kindly run jobs of any kind.
 test_files:
-- test/fixtures/pending/one.json
-- test/fixtures/pending/two.json
-- test/kindly/handlers_test.rb
+- test/fixtures/jobs/fail.rb
 - test/kindly/migration_test.rb
+- test/kindly/registry_test.rb
 - test/kindly/runner_test.rb
 - test/kindly_test.rb

data/bin/kindly

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift File.join(File.dirname(__FILE__), *%w{ .. lib })
-
-require 'kindly'
-require 'mercenary'
-
-Mercenary.program(:kindly) do |p|
-  p.version Kindly::VERSION
-  p.description 'Kindly run migrations of any kind.'
-  p.syntax 'kindly <handler> [options]'
-
-  p.option 'source', '--source DIR', 'Host directory of the kindly directory structure.'
-  p.action do |args, options|
-    if args.empty?
-      puts p
-    elsif options['source']
-      Kindly.run(args.first.to_sym, options['source'])
-    else
-      Kindly.run(args.first.to_sym)
-    end
-  end
-end

data/lib/kindly/handlers/do_nothing.rb

@@ -1,19 +0,0 @@
-require 'kindly'
-
-module Kindly
-  module Handlers
-    class DoNothing
-
-      def ext
-        '*'
-      end
-
-      def run(migration)
-        puts "The handler for #{migration.filename} did nothing."
-      end
-
-    end
-
-    register(:do_nothing, DoNothing.new)
-  end
-end

data/lib/kindly/handlers.rb

@@ -1,29 +0,0 @@
-require 'kindly'
-
-module Kindly
-  module Handlers
-
-    def self.register(name, handler)
-      @@handlers ||= {}
-      @@handlers[name.to_sym] = handler
-    end
-
-    def self.unregister(name)
-      @@handlers.delete(name.to_sym)
-    end
-
-    def self.find(name)
-      if not_registered(name)
-        raise "No handler registered with name #{name.to_sym}."
-      end
-
-      @@handlers[name.to_sym]
-    end
-
-    private
-
-    def self.not_registered(name)
-      !@@handlers.has_key?(name.to_sym)
-    end
-  end
-end

data/lib/kindly/migration.rb

@@ -1,37 +0,0 @@
-require 'kindly'
-require 'fileutils'
-require 'json'
-
-module Kindly
-  class Migration
-
-    attr_reader :filename
-
-    def initialize(filename)
-      @filename = filename
-    end
-
-    def move(destination)
-      path = File.join(Kindly.source, destination)
-      FileUtils.mkdir(path) unless Dir.exist?(path)
-      FileUtils.mv(@filename, path)
-      @filename = File.join(path, File.basename(@filename))
-    end
-
-    def running!
-      move('running')
-      puts "#{@filename} running."
-    end
-
-    def completed!
-      move('completed')
-      puts "#{@filename} completed."
-    end
-
-    def failed!
-      move('failed')
-      puts "#{@filename} failed."
-    end
-
-  end
-end

data/test/fixtures/pending/one.json

@@ -1,3 +0,0 @@
-{
-  "one": 1
-}

data/test/fixtures/pending/two.json

@@ -1,3 +0,0 @@
-{
-  "two": 2
-}

data/test/kindly/handlers_test.rb

@@ -1,24 +0,0 @@
-require 'kindly'
-require 'minitest/autorun'
-
-describe 'Kindly::Handlers' do
-
-  let(:handlers) { Kindly::Handlers }
-  let(:handler) { Kindly::Handlers::DoNothing.new }
-
-  it 'throws if handler is not registered' do
-    assert_raises(RuntimeError) { handlers.find(:missing) }
-  end
-
-  it 'allows handlers to be registered' do
-    handlers.register :different, handler
-    assert handlers.find(:different) == handler
-  end
-
-  it 'allows handlers to be unregistered' do
-    handlers.register :different, handler
-    handlers.unregister :different
-    assert_raises(RuntimeError) { handlers.find(:different) }
-  end
-
-end