porcupine 0.1.0

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in porcupine.gemspec
+gemspec

data/Jarfile

@@ -0,0 +1,3 @@
+jar 'com.netflix.rxjava:rxjava-jruby:0.10.1'
+jar 'com.netflix.hystrix:hystrix-core:1.3.2'
+jar 'org.slf4j:slf4j-simple:1.7.5'

data/Jarfile.lock

@@ -0,0 +1,29 @@
+---
+version: 0.7.5
+groups:
+  default:
+    dependencies:
+    - com.google.code.findbugs:jsr305:jar:2.0.0
+    - com.netflix.archaius:archaius-core:jar:0.4.1
+    - com.netflix.hystrix:hystrix-core:jar:1.3.2
+    - com.netflix.rxjava:rxjava-core:jar:0.10.1
+    - com.netflix.rxjava:rxjava-jruby:jar:0.10.1
+    - commons-configuration:commons-configuration:jar:1.8
+    - commons-lang:commons-lang:jar:2.6
+    - commons-logging:commons-logging:jar:1.1.1
+    - org.slf4j:slf4j-api:jar:1.7.5
+    - org.slf4j:slf4j-simple:jar:1.7.5
+    artifacts:
+    - jar:com.netflix.rxjava:rxjava-jruby:jar:0.10.1:
+        transitive:
+          com.netflix.rxjava:rxjava-core:jar:0.10.1: {}
+    - jar:com.netflix.hystrix:hystrix-core:jar:1.3.2:
+        transitive:
+          com.google.code.findbugs:jsr305:jar:2.0.0: {}
+          com.netflix.archaius:archaius-core:jar:0.4.1:
+            commons-configuration:commons-configuration:jar:1.8:
+              commons-logging:commons-logging:jar:1.1.1: {}
+              commons-lang:commons-lang:jar:2.6: {}
+    - jar:org.slf4j:slf4j-simple:jar:1.7.5:
+        transitive:
+          org.slf4j:slf4j-api:jar:1.7.5: {}

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mike Ragalie
+
+MIT License
+
+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,70 @@
+# Porcupine
+
+Porcupine is a JRuby wrapper for Netflix's [Hystrix library](https://github.com/Netflix/Hystrix).
+It simplifies instantiating HystrixCommands and throws Ruby exceptions for most things that can
+go wrong (execution failures, timeouts, short circuits, no threads in the thread pool).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'porcupine'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install porcupine
+
+## Usage
+
+Instantiate a Porcupine object and give it a name, a group name (optional), a timeout (optional) and a block:
+
+```ruby
+porcupine = Porcupine.new("Sleeping Beauty", "Disney Characters", 10_000) { sleep(50) }
+```
+
+You can also provide a [Setter](https://github.com/Netflix/Hystrix/wiki/Configuration) directly:
+
+```ruby
+setter = com.netflix.hystrix.HystrixCommand::Setter.withGroupKey(com.netflix.hystrix.HystrixCommandGroupKey::Factory.asKey("Disney Characters"))
+                                                   .andCommandKey(com.netflix.hystrix.HystrixCommandKey::Factory.asKey("Sleeping Beauty"))
+porcupine = Porcupine.new(setter) { sleep(50) }
+```
+
+Then either you can request a result immediately:
+
+```ruby
+porcupine.execute
+```
+
+Or retrieve a Future and get the result later:
+
+```ruby
+future = porcupine.queue
+future.get # Blocks on the result
+```
+
+Subscribing to an event is also supported:
+
+```ruby
+observer = porcupine.observe
+observer.subscribe { puts "done!" } # Will puts "done!" when finished
+```
+
+If you provide an onError function, then the function will receive exceptions raised:
+
+```ruby
+observer = porcupine.observe
+observer.subscribe("onNext" => lambda {}, "onError" => lambda {|exception| puts exception}) # Will puts any exception
+```
+
+## 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,10 @@
+task :default => :prepare
+
+task :prepare do
+  require 'lock_jar'
+
+  # get jarfile relative the gem dir
+  lockfile = File.expand_path( "../Jarfile.lock", __FILE__ )
+
+  LockJar.install( :lockfile => lockfile )
+end

data/lib/porcupine/exceptions.rb

@@ -0,0 +1,6 @@
+class Porcupine
+  class FailedExecutionError < RuntimeError; end
+  class RejectedError < RuntimeError; end
+  class ShortCircuitError < RuntimeError; end
+  class TimeoutError < RuntimeError; end
+end

data/lib/porcupine/future.rb

@@ -0,0 +1,12 @@
+require "delegate"
+
+class Porcupine
+  class Future < SimpleDelegator
+    def get(*args)
+      result = __getobj__.get(*args)
+      raise result if result.is_a?(Exception)
+
+      result
+    end
+  end
+end

data/lib/porcupine/observable.rb

@@ -0,0 +1,27 @@
+require "delegate"
+
+class Porcupine
+  class Observable < SimpleDelegator
+    def subscribe(*args, &block)
+      raise ArgumentError unless block_given? || (args.first && args.first["onNext"])
+
+      on_next = if block_given?
+                  block
+                else
+                  args.first["onNext"]
+                end
+
+      on_error = args.first && args.first["onError"]
+
+      wrapped = lambda do |value_or_exception|
+        if value_or_exception.is_a?(Exception)
+          on_error && on_error.call(value_or_exception)
+        else
+          on_next.call(value_or_exception)
+        end
+      end
+
+      __getobj__.subscribe("onNext" => wrapped, "onError" => on_error)
+    end
+  end
+end

data/lib/porcupine/porcupine.rb

@@ -0,0 +1,61 @@
+class Porcupine < com.netflix.hystrix.HystrixCommand
+  java_import com.netflix.hystrix.HystrixCommand::Setter
+  java_import com.netflix.hystrix.HystrixCommandKey
+  java_import com.netflix.hystrix.HystrixCommandGroupKey
+  java_import com.netflix.hystrix.HystrixCommandProperties
+
+  DEFAULT_TIMEOUT = 10_000
+  DEFAULT_GROUP   = "default"
+
+  attr_reader :block
+
+  def initialize(name_or_setter, group=DEFAULT_GROUP, timeout=DEFAULT_TIMEOUT, &block)
+    @block = block
+
+    setter = name_or_setter if name_or_setter.is_a?(com.netflix.hystrix.HystrixCommand::Setter)
+    setter ||= Setter.withGroupKey(HystrixCommandGroupKey::Factory.asKey(group))
+                     .andCommandKey(HystrixCommandKey::Factory.asKey(name_or_setter))
+                     .andCommandPropertiesDefaults(HystrixCommandProperties::Setter().withExecutionIsolationThreadTimeoutInMilliseconds(timeout))
+
+    super(setter)
+  end
+
+  # Only catch Java exceptions since we already handle most exceptions in Observable#get
+  def execute
+    queue.get
+  rescue Java::JavaLang::Throwable => e
+    raise decomposeException(e)
+  end
+
+  def observe
+    Observable.new(super)
+  end
+
+  # Only wrap the outer-most call; otherwise Java gets angry because the class of the
+  # returned object won't match the signature when the calls recurse
+  def toObservable(*args)
+    result = super
+
+    unless caller.first.match(/toObservable/) || caller.first.match(/observe/)
+      result = Observable.new(result)
+    end
+
+    result
+  end
+
+  def queue
+    Future.new(super)
+  end
+
+  def run
+    block.call
+  end
+
+  def getFallback
+    return getFailedExecutionException.getException if isFailedExecution
+    return RejectedError.new                        if isResponseRejected
+    return ShortCircuitError.new                    if isResponseShortCircuited
+    return TimeoutError.new                         if isResponseTimedOut
+    RuntimeError.new
+  end
+end

data/lib/porcupine.rb

@@ -0,0 +1,9 @@
+require "lock_jar"
+
+lockfile = File.expand_path( "../../Jarfile.lock", __FILE__ )
+LockJar.load(lockfile)
+
+require "porcupine/porcupine"
+require "porcupine/exceptions"
+require "porcupine/future"
+require "porcupine/observable"

data/porcupine.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "porcupine"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Mike Ragalie"]
+  spec.email         = ["ragalie@gmail.com"]
+  spec.summary       = "JRuby wrapper for Hystrix"
+  spec.homepage      = "https://github.com/ragalie/porcupine"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions    = ["Rakefile"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "lock_jar"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.0"
+end

data/spec/future_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Porcupine::Future do
+  let(:object) { double("future") }
+  subject(:future) { described_class.new(object) }
+
+  it "is a SimpleDelegator" do
+    future.should be_a(SimpleDelegator)
+  end
+
+  describe "#get" do
+    before { object.stub(:get) { "banana" } }
+
+    it "returns the future value" do
+      future.get.should == "banana"
+    end
+
+    it "raises if the value is an exception" do
+      exception = RuntimeError.new
+      object.stub(:get) { exception }
+      expect { future.get }.to raise_error(exception)
+    end
+  end
+end

data/spec/observable_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Porcupine::Observable do
+  let(:object) { double("observable", :subscribe => nil) }
+  subject(:observable) { described_class.new(object) }
+
+  it "is a SimpleDelegator" do
+    observable.should be_a(SimpleDelegator)
+  end
+
+  describe "#subscribe" do
+    let(:on_next) { lambda {|v| "pumpkin" } }
+    let(:on_error) { lambda {|v| "apples" } }
+    let(:arguments) { observable.subscribe("onNext" => on_next, "onError" => on_error) }
+
+    describe "arguments" do
+      it "accepts a block" do
+        observable.subscribe {}
+      end
+
+      it "accepts an onNext parameter" do
+        observable.subscribe("onNext" => lambda {})
+      end
+
+      it "raises otherwise" do
+        expect { observable.subscribe("cat!") }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "calls subscribe with a block" do
+      object.stub(:subscribe) {|arg| arg}
+      observable.subscribe(&on_next)
+      arguments["onNext"].call(1).should == "pumpkin"
+    end
+
+    it "calls subscribe with the provided onNext method" do
+      object.stub(:subscribe) {|arg| arg}
+      arguments["onNext"].call(1).should == "pumpkin"
+    end
+
+    it "calls subscribe with the provided onError method" do
+      object.stub(:subscribe) {|arg| arg}
+      arguments["onError"].should == on_error
+    end
+
+    describe "onNext method" do
+      before { object.stub(:subscribe) {|arg| arg} }
+
+      it "calls the success method" do
+        wrapped = arguments["onNext"]
+
+        on_next.should_receive(:call).with("pony")
+        wrapped.call("pony")
+      end
+
+      it "calls the error method if the value is an exception" do
+        wrapped = arguments["onNext"]
+
+        exception = RuntimeError.new
+        on_error.should_receive(:call).with(exception)
+        wrapped.call(exception)
+      end
+
+      it "does nothing if there's no on_error" do
+        arguments = observable.subscribe(&on_next)
+        wrapped = arguments["onNext"]
+
+        exception = RuntimeError.new
+        on_error.should_not_receive(:call)
+        on_next.should_not_receive(:call)
+        wrapped.call(exception)
+      end
+    end
+  end
+end

data/spec/porcupine_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+describe Porcupine do
+  let(:block) { lambda {} }
+
+  subject(:porcupine) do
+    described_class.new("test", &block)
+  end
+
+  after do
+    com.netflix.hystrix.Hystrix.reset
+  end
+
+  describe "#initialize" do
+    it "handles a name, group, timeout and block" do
+      porcupine = described_class.new("blah", "blah_group", 1_000, &block)
+      porcupine.should be_a(com.netflix.hystrix.HystrixCommand)
+      porcupine.getCommandKey.name.should == "blah"
+      porcupine.getCommandGroup.name.should == "blah_group"
+      porcupine.getProperties.executionIsolationThreadTimeoutInMilliseconds.get.should == 1_000
+      porcupine.block.should == block
+    end
+
+    it "handles a setter" do
+      setter = com.netflix.hystrix.HystrixCommand::Setter.withGroupKey(com.netflix.hystrix.HystrixCommandGroupKey::Factory.asKey("blah2_group"))
+                                                         .andCommandKey(com.netflix.hystrix.HystrixCommandKey::Factory.asKey("blah2"))
+
+      porcupine = described_class.new(setter, &block)
+      porcupine.should be_a(com.netflix.hystrix.HystrixCommand)
+      porcupine.getCommandKey.name.should == "blah2"
+      porcupine.getCommandGroup.name.should == "blah2_group"
+      porcupine.block.should == block
+    end
+
+    it "uses the defaults if none are provided" do
+      porcupine = described_class.new("blah3", &block)
+      porcupine.getCommandKey.name.should == "blah3"
+      porcupine.getCommandGroup.name.should == "default"
+      porcupine.getProperties.executionIsolationThreadTimeoutInMilliseconds.get.should == 10_000
+      porcupine.block.should == block
+    end
+  end
+
+  describe "#execute" do
+    let(:future) { double("future") }
+
+    before { porcupine.stub(:queue) { future } }
+
+    it "calls queue.get" do
+      porcupine.should_receive(:queue) { future }
+      future.should_receive(:get)
+
+      porcupine.execute
+    end
+
+    it "lets Ruby exceptions propogate" do
+      future.stub(:get).and_raise(RuntimeError)
+      porcupine.should_not_receive(:decomposeException)
+
+      expect { porcupine.execute }.to raise_error(RuntimeError)
+    end
+
+    it "catches Java exceptions and runs them through #decomposeException" do
+      exception = java.lang.Throwable.new
+      future.stub(:get).and_raise(exception)
+      porcupine.should_receive(:decomposeException).with(exception) { java.lang.Exception.new }
+
+      expect { porcupine.execute }.to raise_error(Java::JavaLang::Exception)
+    end
+  end
+
+  describe "#observe" do
+    it "wraps the result in an Observable" do
+      observable = porcupine.observe
+      observable.should be_a(Porcupine::Observable)
+      observable.__getobj__.should be_a(Java::Rx::Observable)
+    end
+  end
+
+  describe "#toObservable" do
+    it "wraps the result in an Observable with no args" do
+      observable = porcupine.toObservable
+      observable.should be_a(Porcupine::Observable)
+      observable.__getobj__.should be_a(Java::Rx::Observable)
+    end
+
+    it "wraps the result in an Observable with one arg" do
+      observable = porcupine.toObservable(Java::RxConcurrency::Schedulers.threadPoolForComputation)
+      observable.should be_a(Porcupine::Observable)
+      observable.__getobj__.should be_a(Java::Rx::Observable)
+    end
+  end
+
+  describe "#queue" do
+    it "wraps the result in a Future" do
+      future = porcupine.queue
+      future.should be_a(Porcupine::Future)
+      future.__getobj__.class.ancestors.should include(Java::JavaUtilConcurrent::Future)
+      future.cancel(true)
+    end
+  end
+
+  describe "#run" do
+    it "calls the block" do
+      block.should_receive(:call)
+      porcupine.run
+    end
+  end
+
+  describe "#getFallback" do
+    it "returns the failure exception if the block failed" do
+      exception = Exception.new
+
+      porcupine.stub(:isFailedExecution) { true }
+      porcupine.stub_chain(:getFailedExecutionException, :getException) { exception }
+      porcupine.getFallback.should == exception
+    end
+
+    it "returns a RejectedError if the response was rejected" do
+      porcupine.stub(:isResponseRejected) { true }
+      porcupine.getFallback.should be_a(Porcupine::RejectedError)
+    end
+
+    it "returns a ShortCircuitError if the response was short circuited" do
+      porcupine.stub(:isResponseShortCircuited) { true }
+      porcupine.getFallback.should be_a(Porcupine::ShortCircuitError)
+    end
+
+    it "returns a TimeoutError if the response timed out" do
+      porcupine.stub(:isResponseTimedOut) { true }
+      porcupine.getFallback.should be_a(Porcupine::TimeoutError)
+    end
+
+    it "returns a RuntimeError otherwise" do
+      porcupine.getFallback.should be_a(RuntimeError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "porcupine"

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: porcupine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease:
+platform: ruby
+authors:
+- Mike Ragalie
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lock_jar
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    none: false
+  prerelease: false
+  type: :development
+description:
+email:
+- ragalie@gmail.com
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- Jarfile
+- Jarfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/porcupine.rb
+- lib/porcupine/exceptions.rb
+- lib/porcupine/future.rb
+- lib/porcupine/observable.rb
+- lib/porcupine/porcupine.rb
+- porcupine.gemspec
+- spec/future_spec.rb
+- spec/observable_spec.rb
+- spec/porcupine_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ragalie/porcupine
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: JRuby wrapper for Hystrix
+test_files:
+- spec/future_spec.rb
+- spec/observable_spec.rb
+- spec/porcupine_spec.rb
+- spec/spec_helper.rb
+has_rdoc: