jruby_bridge 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5367f5e9bf3e3c2bedc9a87cf8a4aca9689a2b8a
+  data.tar.gz: 9180d4e1e93394da2f89b0b3425b1fe0c6ee412a
+SHA512:
+  metadata.gz: efa6be4f5888e1ab81e64c28820a732aed2a72636b760107b76dd49ea63fe7015ff5378c304d6384b519be0799d467b1f813528d88bf5f2e56619aeee6f7530b
+  data.tar.gz: 42e0731d46a569210842806b83b569921facd185109ed123aa5488e83ac5d985dfe15b2f58a6191226e057f7e3e3b39ae264f7f62725f1723b11cf9cf72fe8f9

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Peter Hollows
+
+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,71 @@
+# jruby_bridge
+
+`jruby_bridge` proxies chunks of ruby code through to JRuby DRB Server and fetches the results.
+
+This is useful for situations like having to plug your freshly minted Ruby app into some godawful legacy enterprise database, or other scenarios laced with java (we nearly called this barge_pole).
+
+Based on, and forked from https://github.com/mkfs/jruby-bridge
+"See http://entrenchant.blogspot.com/2012/07/drb-jruby-bridge.html for full discussion."
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jruby_bridge'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jruby_bridge
+
+Then pat a kitten :tiger:
+
+## Usage by Example
+
+```ruby
+require 'jruby_bridge'
+
+# Start the JRuby service process
+JRubyBridge::Service.with_service do
+
+  # Now, every new SomeClass lives remotely
+  SomeClass.send :include, JRubyBridge::ObjectProxy
+
+  # Make a remote object
+  remote_object = SomeClass.new 'some', 'args'
+
+  # executes in the JRuby process
+  new_object = remote_object.do_stuff
+
+  # also in the JRuby process (pass by ref)
+  new_object.do_more_stuff
+
+  # lambdas are executed in this process
+  new_object.each { |thing| process thing }
+
+end # Stop the JRuby service process
+```
+
+```ruby
+# You can also control the service manually
+JRubyBridge::Service.start
+JRubyBridge::Service.stop
+```
+
+## TODO
+
+1. Ahh, some tests?
+2. Convince the Enterprise to stop using commercial databases
+3. Lazy-launching of the service process
+4. Timeouts on the service process?
+
+## 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 @@
+require "bundler/gem_tasks"

data/jruby_bridge.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jruby_bridge/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jruby_bridge"
+  spec.version       = JrubyBridge::VERSION
+  spec.authors       = ["mkfs", "Peter Hollows"]
+  spec.email         = ["peter.hollows@gmail.com"]
+  spec.description   = %q{jruby_bridge proxies chunks of ruby code through to JRuby DRB Server and fetches the results.}
+  spec.summary       = spec.description
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/jruby_bridge.rb

@@ -0,0 +1,6 @@
+require "jruby_bridge/version"
+require 'jruby_bridge/object_proxy'
+
+module JRubyBridge
+  # Your code goes here...
+end

data/lib/jruby_bridge/object_proxy.rb

@@ -0,0 +1,23 @@
+require 'jruby_bridge/service'
+
+module JRubyBridge
+
+=begin rdoc
+A module that patches initialization behavior to cause
+new instances to reside on the JRuby DRb service.
+=end
+  module ObjectProxy
+
+    def self.included(base)
+      base.class_eval do
+        include DRb::DRbUndumped
+
+        def self.new(*args)
+          service = Service.new_drb_object
+          service.proxy_new(self, *args)
+        end
+      end
+    end
+
+  end
+end

data/lib/jruby_bridge/server.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env jruby
+
+raise ScriptError.new("JRuby is required") unless RUBY_PLATFORM =~ /java/
+
+require 'java'
+require File.join(File.dirname(__FILE__), 'service')
+
+JRubyBridge::Service.drb_start ARGV.first if __FILE__ == $0

data/lib/jruby_bridge/service.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+require 'drb'
+
+=begin rdoc
+A Ruby class for launching a JRuby application in a child process, using
+DRuby to communicate between them.
+=end
+module JRubyBridge
+
+  class JRubyExecError < StandardError; end
+  class DRbConnectionError < StandardError; end
+
+=begin rdoc
+A Ruby-managed JRuby application.
+=end
+  class Service
+    # Path to JRuby application
+    DAEMON = File.join(File.dirname(__FILE__), 'server.rb')
+    # Port to listen on in JRuby
+    PORT = 44344
+    # Time to allow JRuby to initialize, in 100-ms increments
+    TIMEOUT = 300
+
+    def proxy_new(klass, *args)
+      klass.new *args
+    end
+
+    def stop
+      DRb.stop_service
+    end
+
+    def self.with_service(&block)
+      start
+      yield
+    ensure
+      stop
+    end
+
+    def self.start
+      return @pid if @pid
+      cls = self
+      @pid = Process.fork do
+        exit(cls.exec PORT)
+      end
+      # TODO : check child exit status and raise JRubyExecError
+      Process.detach(@pid)
+
+      connected = false
+      TIMEOUT.times do
+        begin
+          DRb::DRbObject.new_with_uri(default_uri).to_s
+          connected = true
+          break
+        rescue DRb::DRbConnError
+          sleep 0.1
+        end
+      end
+      raise DRbConnectionError.new("Could not connect to #{default_uri}") if \
+            (! connected)
+    end
+
+    def self.stop
+      service_send :stop
+    end
+
+    # Replace current process with JRuby running JRubyBridge::Service
+    def self.exec(port)
+      jruby = get_jruby
+      command = "#{jruby} #{DAEMON} #{port || ''}"
+      puts "Running #{command}"
+      Kernel.exec command if jruby
+
+      # Note: a raised exception goes nowhere: instead use exit status
+      $stderr.puts "No JRUBY found!"
+      return 1
+    end
+
+    # Called by the server script in JRuby context
+    def self.drb_start(port)
+      port ||= PORT
+
+      DRb.start_service "druby://localhost:#{port.to_i}", self.new
+
+      cls = self
+      trap('HUP') { DRb.stop_service; cls.drb_start(port) }
+      trap('INT') { puts 'Stopping jruby service'; DRb.stop_service }
+
+      DRb.thread.join
+    end
+
+    def self.default_uri
+      "druby://localhost:#{PORT}"
+    end
+
+    # Return command to launch JRuby interpreter
+    def self.get_jruby
+      # FIXME: this should detect RVM first and system second
+
+      # 1. detect system JRuby
+      jruby = `which jruby`
+      return jruby.chomp if (! jruby.empty?)
+
+      # 2. detect RVM-managed JRuby
+      return nil if (`which rvm`).empty?
+      jruby = `rvm list`.split("\n").select { |rb| rb.include? 'jruby' }.first
+      return nil if (! jruby)
+
+      "rvm #{jruby.strip.split(' ').first} do ruby "
+    end
+
+    # this will return a new DRuby connection
+    def self.service_send(method, *args)
+      begin
+        new_drb_object.tap { |obj| obj.send(method, *args) }
+      rescue DRb::DRbConnError => e
+        # $stderr.puts e.backtrace.join("\n")
+        raise DRbConnectionError.new(e.message)
+      end
+    end
+
+    def self.new_drb_object
+      DRb::DRbObject.new_with_uri(default_uri)
+    end
+
+  end
+end

data/lib/jruby_bridge/version.rb

@@ -0,0 +1,3 @@
+module JrubyBridge
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: jruby_bridge
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- mkfs
+- Peter Hollows
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: jruby_bridge proxies chunks of ruby code through to JRuby DRB Server
+  and fetches the results.
+email:
+- peter.hollows@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jruby_bridge.gemspec
+- lib/jruby_bridge.rb
+- lib/jruby_bridge/object_proxy.rb
+- lib/jruby_bridge/server.rb
+- lib/jruby_bridge/service.rb
+- lib/jruby_bridge/version.rb
+homepage: ''
+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.0.3
+signing_key: 
+specification_version: 4
+summary: jruby_bridge proxies chunks of ruby code through to JRuby DRB Server and
+  fetches the results.
+test_files: []