heracles-wrapper 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.3-p286@heracles-wrapper"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create use  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    exit 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+if command -v bundle && [[ -s Gemfile ]]
+then
+  bundle
+fi
+
+

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.3
+  - 1.8.7
+gemfile:
+  - Gemfile
+notifications:
+  email:
+    recipients:
+      - jfriesen@nd.edu
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in heracles-wrapper.gemspec
+gemspec
+
+gem 'rake'

data/LICENSE.txt

@@ -0,0 +1,14 @@
+##########################################################################
+# Copyright 2012 University of Notre Dame
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,74 @@
+# Heracles::Wrapper
+
+[![Build Status](https://secure.travis-ci.org/ndlib/heracles-wrapper.png)](http://travis-ci.org/ndlib/heracles-wrapper)
+
+API Wrapper for [Heracles](https://github.com/ndlib/heracles) workflow manager.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'heracles-wrapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install heracles-wrapper
+
+Get your Heracles API key
+
+Once installed in your application use rails generate:
+
+    rails generate heracles:wrapper:install -k <API_KEY_FROM_HERACLES>
+
+## Usage
+
+    Heracles::Wrapper.service(
+      :create_job,
+      :workflow_name => 'RabbitWarren',
+      :parameters => {
+        :callback_url => 'http://google.com'
+      }
+    )
+
+## Test Usage
+
+    require 'heracles-wrapper/test_helper'
+
+    describe YourObject do
+      include Heracles::Wrapper::TestHelper
+      let(:service) {
+        Heracles::Wrapper.service(
+          :create_job,
+          :workflow_name => 'RabbitWarren',
+          :parameters => {
+            :callback_url => 'http://google.com'
+          }
+        )
+      }
+
+      it 'should wrap the API with failing calls' do
+        with_heracles_service_failure_stub(:create_job, 'Failure') do
+          lambda {
+            service.call
+          }.must_raise(Heracles::Wrapper::RequestFailure, /Failure/)
+        end
+      end
+
+      it 'should wrap the API' do
+        with_heracles_service_stub(:create_job) do
+          service.call.job_id.must_be_kind_of Fixnum
+        end
+      end
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new('spec') do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :spec

data/heracles-wrapper.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'heracles-wrapper/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "heracles-wrapper"
+  gem.version       = Heracles::Wrapper::VERSION
+  gem.authors       = [
+    "Jeremy Friesen"
+  ]
+  gem.email         = [
+    "jeremy.n.friesen@gmail.com"
+  ]
+  gem.description   = %q{API Wrapper for Heracles workflow manager}
+  gem.summary       = %q{API Wrapper for Heracles workflow manager}
+  gem.homepage      = "https://github.com/ndlib/heracles-wrapper"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rest-client"
+  gem.add_dependency "morphine"
+  gem.add_dependency "json" if RUBY_VERSION =~ /\A1\.8/
+  gem.add_dependency "method_decorators"
+  gem.add_development_dependency "webmock"
+  gem.add_development_dependency "debugger" if RUBY_VERSION !~ /\A1\.8/
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-matchers"
+  gem.add_development_dependency "rails"
+
+end

data/lib/heracles-wrapper/config.rb

@@ -0,0 +1,17 @@
+module Heracles
+  module Wrapper
+    HERACLES_BASE_URL = 'https://heracles.library.nd.edu'.freeze
+    class Config
+      attr_accessor :api_key
+      def initialize
+        yield(self) if block_given?
+      end
+
+      attr_writer :heracles_base_url
+      def heracles_base_url
+        @heracles_base_url || Heracles::Wrapper::HERACLES_BASE_URL
+      end
+    end
+  end
+end
+

data/lib/heracles-wrapper/exceptions.rb

@@ -0,0 +1,15 @@
+module Heracles
+  module Wrapper
+    class RequestFailure < RuntimeError
+      attr_reader :code, :messages, :response
+      def initialize(response)
+        @code = response.respond_to?(:code) ? response.code : 500
+        @messages = response.respond_to?(:body) ? response.body : ''
+        @response = response
+        super("code: #{@code}")
+      end
+    end
+    class ConfigurationError < RuntimeError
+    end
+  end
+end

data/lib/heracles-wrapper/notification_response.rb

@@ -0,0 +1,38 @@
+require 'method_decorators'
+require 'method_decorators/decorators/precondition'
+
+module Heracles
+  module Wrapper
+  end
+end
+
+class Heracles::Wrapper::NotificationResponse
+  extend MethodDecorators
+  attr_reader(
+    :job_id,
+    :job_status,
+    :notification_payload,
+    :one_time_notification_key
+  )
+  +Precondition.new { |params|
+    params[:job_id] &&
+    params[:job_status] &&
+    params[:notification_payload].respond_to?(:to_hash)
+  }
+  def initialize(params)
+    @notification_payload = params.fetch(:notification_payload).to_hash
+    @job_id = params.fetch(:job_id).to_i
+    @job_status = params.fetch(:job_status).to_sym
+    @one_time_notification_key = params.fetch(:one_time_notification_key, nil)
+  end
+
+  def method_missing(method_name, *args, &block)
+    super
+  rescue NoMethodError
+    @notification_payload.send(method_name, *args, &block)
+  end
+
+  def respond_to?(method_name)
+    super || @notification_payload.respond_to?(method_name)
+  end
+end

data/lib/heracles-wrapper/request/create_job.rb

@@ -0,0 +1,63 @@
+require 'uri'
+require 'json'
+require 'rest-client'
+require File.expand_path("../exceptions", File.dirname(__FILE__))
+require File.expand_path("../request_success", File.dirname(__FILE__))
+
+
+module Heracles
+  module Wrapper
+    module Request
+    end
+  end
+end
+
+class Heracles::Wrapper::Request::CreateJob
+  attr_reader(
+    :config,
+    :workflow_name,
+    :parent_job_id,
+    :parameters,
+    :url
+  )
+  def initialize(config, options = {})
+    @config = config
+    @workflow_name = options.fetch(:workflow_name)
+    @parent_job_id = options.fetch(:parent_job_id, nil)
+    @parameters = options.fetch(:parameters, {})
+    @url = URI.parse(File.join(config.heracles_base_url, 'jobs'))
+  end
+
+  def as_json
+    {
+      :api_key => config.api_key,
+      :workflow_name => workflow_name,
+      :parameters => parameters
+    }.tap {|hash|
+      hash[:parent_job_id] = parent_job_id if parent_job_id
+    }
+  end
+
+  # Need to accept a self-signed cert.
+  # Hits a given URL
+  # Syncrhonously waits for response.
+  def call
+    decorate_response(
+      RestClient.post(
+        url.to_s,
+        as_json,
+        {
+          :content_type => :json,
+          :accept => :json,
+          :verify_ssl => OpenSSL::SSL::VERIFY_NONE
+        }
+      )
+    )
+  rescue RestClient::Exception => e
+    raise Heracles::Wrapper::RequestFailure.new(e.response)
+  end
+  protected
+  def decorate_response(response)
+    Heracles::Wrapper::RequestSuccess.new(response)
+  end
+end

data/lib/heracles-wrapper/request.rb

@@ -0,0 +1,6 @@
+module Heracles
+  module Wrapper
+    module Request
+    end
+  end
+end

data/lib/heracles-wrapper/request_success.rb

@@ -0,0 +1,25 @@
+require File.expand_path("exceptions", File.dirname(__FILE__))
+require 'rest-client'
+require 'json'
+require 'delegate'
+
+module Heracles
+  module Wrapper
+    class RequestSuccess < DelegateClass(RestClient::Response)
+      attr_reader(
+        :job_id,
+        :location,
+        :messages,
+        :code
+      )
+      def initialize(http_response)
+        super(http_response)
+        @json = JSON.parse(http_response.body)
+        @job_id = @json.fetch('job_id').to_i
+        @messages = @json.fetch('messages',[]).to_a
+        @location = http_response.headers.fetch(:location)
+        @code = http_response.code
+      end
+    end
+  end
+end

data/lib/heracles-wrapper/test_helper.rb

@@ -0,0 +1,67 @@
+require File.expand_path("../heracles-wrapper", File.dirname(__FILE__))
+require File.expand_path("exceptions", File.dirname(__FILE__))
+require 'ostruct'
+module Heracles::Wrapper
+  module TestHelper
+    RESPONSE_JOB_ID = 1234.freeze
+    RESPONSE_CODE = 201.freeze
+
+    def with_heracles_service_failure_stub(service_name, messages = [])
+      wrap_service_with_proxy(service_name) do
+        Heracles::Wrapper.send(
+          "#{service_name}_service=",
+          lambda { |config,options|
+            OpenStruct.new(
+              :config => config,
+              :workflow_name => options.fetch(:workflow_name),
+              :parent_job_id => options.fetch(:parent_job_id, nil),
+              :parameters => options.fetch(:parameters, {})
+            ).tap { |obj|
+              def obj.call
+                raise Heracles::Wrapper::RequestFailure.new(messages)
+              end
+            }
+          }
+        )
+        yield
+      end
+    end
+    # Presently I'm leaning on the implementation details of :create_job
+    # for returning the API.
+    def with_heracles_service_stub(service_name, response = {})
+      wrap_service_with_proxy(service_name) do |proxy|
+
+        response[:job_id] ||= RESPONSE_JOB_ID
+        response[:location] ||= File.join(
+          Heracles::Wrapper.config.heracles_base_url,
+          "/jobs/#{response[:job_id]}"
+        )
+        response[:code] ||= RESPONSE_CODE
+        response[:messages] ||= []
+
+        Heracles::Wrapper.send(
+          "#{service_name}_service=",
+          lambda { |config,options|
+            OpenStruct.new(
+              :config => config,
+              :workflow_name => options.fetch(:workflow_name),
+              :parent_job_id => options.fetch(:parent_job_id, nil),
+              :parameters => options.fetch(:parameters, {}),
+              :call => OpenStruct.new(response)
+            )
+          }
+        )
+        yield
+      end
+    end
+
+    private
+
+    def wrap_service_with_proxy(service_name)
+      old_service = Heracles::Wrapper.send("#{service_name}_service")
+      yield
+    ensure
+      Heracles::Wrapper.send("#{service_name}_service=", old_service)
+    end
+  end
+end

data/lib/heracles-wrapper/version.rb

@@ -0,0 +1,5 @@
+module Heracles
+  module Wrapper
+    VERSION = "0.0.1"
+  end
+end

data/lib/heracles-wrapper.rb

@@ -0,0 +1,38 @@
+require File.expand_path("heracles-wrapper/version", File.dirname(__FILE__))
+require File.expand_path("heracles-wrapper/config", File.dirname(__FILE__))
+require File.expand_path("heracles-wrapper/exceptions", File.dirname(__FILE__))
+require File.expand_path("heracles-wrapper/request/create_job", File.dirname(__FILE__))
+require 'morphine'
+module Heracles
+  module Wrapper
+    module_function
+    def configure(&block)
+      @config = Config.new(&block)
+    end
+
+    def config
+      if @config.nil?
+        raise ConfigurationError.new("#{self}.config not set")
+      end
+      if @config.api_key.nil?
+        raise ConfigurationError.new("#{self}.config.api_key is invalid")
+      end
+      @config
+    end
+
+    def clear_config!
+      @config = nil
+    end
+
+    def service(service_name, options = {})
+      send("#{service_name}_service").call(config,options)
+    end
+    class << self
+      include Morphine
+      private
+      register :create_job_service do
+        Heracles::Wrapper::Request::CreateJob.method(:new)
+      end
+    end
+  end
+end

data/lib/rails/generators/heracles/wrapper/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generate the config for Heracles
+
+Example:
+    rails generate heracles:wrapper:install -k <API_KEY_FOR_PRODUCTION_HERACLES>
+
+    This will create:
+        config/initializers/heracles-wrapper.rb

data/lib/rails/generators/heracles/wrapper/install/install_generator.rb

@@ -0,0 +1,42 @@
+require 'rails/generators'
+module Heracles
+  module Wrapper
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option(
+        :api_key,
+        :aliases => "-k",
+        :type => :string,
+        :desc => "Your Heracles API key",
+        :required => true
+      )
+
+      def install
+        ensure_api_key_was_configured
+        generate_config
+      end
+
+      private
+      def ensure_api_key_was_configured
+        if api_key_configured?
+          puts "Already configured"
+          exit
+        end
+      end
+
+      def generate_config
+        template 'config.rb', initializer_filename
+      end
+
+      def initializer_filename
+        'config/initializers/heracles-wrapper.rb'
+      end
+
+      def api_key_configured?
+        File.exists?(initializer_filename)
+      end
+
+    end
+  end
+end

data/lib/rails/generators/heracles/wrapper/install/templates/config.rb

@@ -0,0 +1,11 @@
+Heracles::Wrapper.configure do |config|
+  if Rails.env.production?
+    config.api_key = "<%= options[:api_key] %>"
+  elsif Rails.env.preproduction?
+    config.api_key = "change-me-as-needed"
+    config.heracles_base_url = 'https://heraclespprd.library.nd.edu'
+  else
+    config.api_key = "change-me-as-needed"
+    config.heracles_base_url = 'http://localhost:8765'
+  end
+end

data/lib/rails/generators/heracles/wrapper/notification_response/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generate a notification response for Heracles
+
+Example:
+    rails generate heracles:wrapper:notification_response <NAME>
+
+    This will create:
+        app/models/<NAME>.rb
+        spec/models/<NAME>.rb

data/lib/rails/generators/heracles/wrapper/notification_response/notification_response_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+module Heracles
+  module Wrapper
+    class NotificationResponseGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_model
+        template(
+          'notification_response.rb.erb',
+          File.join('app/models/', "#{file_name}.rb")
+        )
+      end
+      def create_spec
+        template(
+          'notification_response_spec.rb.erb',
+          File.join('spec/models/',"#{file_name}_spec.rb")
+        )
+      end
+    end
+  end
+end

data/lib/rails/generators/heracles/wrapper/notification_response/templates/notification_response.rb.erb

@@ -0,0 +1,17 @@
+require 'heracles/wrapper/notification_response'
+require 'delegate'
+
+# Using the DelegateClass inheritance option so that the Preconditions of the
+# base Heracles::Wrapper::NotificationResponse are preserved.
+class <%= class_name %> < DelegateClass(Heracles::Wrapper::NotificationResponse)
+  def initialize(params)
+    super(Heracles::Wrapper::NotificationResponse.new(params))
+
+    # The following two lines are logically equivalent
+    #   @pid = fetch(:pid)
+    #   @pid = params.fetch(:notification_payload).fetch(:pid)
+    #
+    # You may also want to define, at the class level the following:
+    #   attr_reader :pid
+  end
+end

data/lib/rails/generators/heracles/wrapper/notification_response/templates/notification_response_spec.rb.erb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe <%= class_name %> do
+  subject { <%= class_name %>.new(params) }
+  let(:params) {
+    {
+      :job_id => '1234',
+      :one_time_notification_key => 'abc',
+      :job_status => 'ok',
+      :notification_payload => expected_notification_payload
+    }
+  }
+  let(:expected_notification_payload) { {:hello => 'world'} }
+
+  describe 'standard behavior' do
+    it 'should have #job_id' do
+      subject.job_id.should == params.fetch(:job_id).to_i
+    end
+    it 'should have #job_status' do
+      subject.job_status.should == params.fetch(:job_status).to_sym
+    end
+    it 'should have #notification_payload' do
+      subject.notification_payload.should == params.
+        fetch(:notification_payload).to_sym
+    end
+    it 'should behave as a the :notification_payload hash' do
+      subject[:hello].should == params[:notification_payload][:hello]
+      subject.fetch(:hello).should == params[:notification_payload][:hello]
+    end
+  end
+end