redstorm 0.5.1 → 0.6.0

data/examples/simple/word_count_bolt.rb

@@ -9,7 +9,7 @@ module RedStorm
       # block declaration style using auto-emit (default)
       #
       on_receive do |tuple|
-        word = tuple.getString(0)
+        word = tuple.getValue(0).to_s
         @counts[word] += 1
 
         [word, @counts[word]]

data/lib/red_storm.rb

@@ -1,42 +1,6 @@
-# this is the entry point for these two contexts:
-# - running red_storm.rake
-# - at remote cluster topology execution. Once topology_launcher.rb has submitted the topology
-#   the spouts and bolts classes will be instanciated and will require red_storm.rb
-
-# we depends on rubygems begings loaded at this point for setting up gem/bundle environments
-# explicitely requiring rubygems is required in remote cluster environment
 require 'rubygems'
 
-# setup some environment constants
-# this is required here and in topology_launcher.rb which are both 
-# entry points in redstorm. 
-module RedStorm
-  TOPOLOGY_LAUNCHED = defined?(LAUNCH_PATH)
-
-  # do not redefine if already defined in topology_launcher.rb
-  unless TOPOLOGY_LAUNCHED
-    LAUNCH_PATH = File.expand_path(File.dirname(__FILE__))
-    JAR_CONTEXT = !!(LAUNCH_PATH =~ /\.jar!$/)
-
-    if JAR_CONTEXT
-      BASE_PATH = LAUNCH_PATH
-    else
-      BASE_PATH = Dir.pwd
-    end
-  end
-end
-
-unless RedStorm::JAR_CONTEXT
-  # in JAR context red_storm.rb and red_storm/* is in the JAR root.
-  # otherwise this is in lib/...
-  $:.unshift "#{RedStorm::BASE_PATH}/lib" 
-end
-
-unless RedStorm::TOPOLOGY_LAUNCHED
-  require 'red_storm/environment'
-  RedStorm.setup_gems if RedStorm::JAR_CONTEXT
-end
-
+require 'red_storm/environment'
 require 'red_storm/version'
 require 'red_storm/configuration'
 require 'red_storm/application'

data/lib/red_storm/application.rb

@@ -1,31 +1,33 @@
 module RedStorm
-
-  DEFAULT_RUBY_VERSION = "--1.8"
-  RUNTIME = {}
   
   class Application 
     TASKS_FILE = "#{RedStorm::REDSTORM_HOME}/lib/tasks/red_storm.rake" 
 
     def usage
-      puts("usage: redstorm [--1.8|--1.9]  install | deps | build | examples | gems | bundle [--gemfile GEMFILE_PATH] | jar DIR1, DIR2, ... | local TOPOLOGY_CLASS_PATH")
+      puts("usage: redstorm install")
+      puts("       redstorm deps")
+      puts("       redstorm build")
+      puts("       redstorm examples")
+      puts("       redstorm bundle [BUNDLER_GROUP]")
+      puts("       redstorm jar DIR1, [DIR2, ...]")
+      puts("       redstorm local [--1.8|--1.9] TOPOLOGY_CLASS_PATH")
+      puts("       redstorm cluster [--1.8|--1.9] TOPOLOGY_CLASS_PATH")
       exit(1)
     end
 
     def run(args)
       if args.size > 0
-        version = args.delete("--1.8") || args.delete("--1.9") || DEFAULT_RUBY_VERSION
-        RUNTIME['RUBY_VERSION'] = version
-
-        if ["install", "examples", "jar", "gems", "bundle", "deps", "build"].include?(args[0])
+        if ["install", "examples", "jar", "bundle", "deps", "build"].include?(args[0])
           load(TASKS_FILE)
           Rake::Task[args.shift].invoke(args.join(":"))
           exit
-        elsif args.size >= 2 && args.include?("local") 
-          args.delete("local")
+        elsif args.size >= 2 && ["local", "cluster"].include?(args[0])
+          env = args.delete_at(0)
+          version = args.delete("--1.8") || args.delete("--1.9")
           if args.size == 1
             file = args[0]
             load(TASKS_FILE)
-            Rake::Task['launch'].invoke("local", file)
+            Rake::Task['launch'].invoke(env, version, file)
             exit
           end
         end
@@ -33,4 +35,5 @@ module RedStorm
       usage
     end
   end
+
 end

data/lib/red_storm/configurator.rb

@@ -3,12 +3,13 @@ module RedStorm
   class Configurator
     attr_reader :config
 
-    def initialize
+    def initialize(defaults = {})
       @config = Backtype::Config.new
+      defaults.each{|attribute, value| @config.put(attribute.to_s, value)}
     end
 
     def set(attribute, value)
-      @config.put(attribute, value)
+      @config.put(attribute.to_s, value)
     end
 
     def method_missing(sym, *args)

data/lib/red_storm/environment.rb

@@ -1,28 +1,38 @@
 module RedStorm
-  # LAUNCH_PATH, BASE_PATH and JAR_CONTEXT must be set before requiring this module
-  # typically, they must be set in either red_storm.rb and topology_launcher.rd
-  # which are the 2 entry points
+
+  LAUNCH_PATH = File.expand_path(File.dirname(__FILE__))
+  JAR_CONTEXT = !!(LAUNCH_PATH =~ /\.jar!\/red_storm$/)
 
   if JAR_CONTEXT
-    REDSTORM_HOME = LAUNCH_PATH
-    TARGET_PATH = LAUNCH_PATH
-    BUNDLE_GEMFILE = "#{TARGET_PATH}/bundler/Gemfile"
-    BUNDLE_PATH = "#{TARGET_PATH}/bundler/#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}/"
+    BASE_PATH = File.expand_path(LAUNCH_PATH + '/..')
+    REDSTORM_HOME = BASE_PATH
+    TARGET_PATH = BASE_PATH
+
     GEM_PATH = "#{TARGET_PATH}/gems/"
+    ENV["GEM_PATH"] = GEM_PATH
   else
-    REDSTORM_HOME = File.expand_path(LAUNCH_PATH + '/..')
+    BASE_PATH = Dir.pwd
+    REDSTORM_HOME = File.expand_path(LAUNCH_PATH + '/../..')
     TARGET_PATH = "#{BASE_PATH}/target"
-    BUNDLE_GEMFILE = "#{TARGET_PATH}/gems/bundler/Gemfile"
-    BUNDLE_PATH = "#{TARGET_PATH}/gems/bundler/#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}/"
-    GEM_PATH = "#{TARGET_PATH}/gems/gems"
   end
 
-  def setup_gems
-    ENV['BUNDLE_GEMFILE'] = RedStorm::BUNDLE_GEMFILE
-    ENV['BUNDLE_PATH'] = RedStorm::BUNDLE_PATH
-    ENV["GEM_PATH"] = RedStorm::GEM_PATH
-    ENV['BUNDLE_DISABLE_SHARED_GEMS'] = "1"
+  def current_ruby_mode
+    RUBY_VERSION =~ /(\d+\.\d+)(\.\d+)*/
+    raise("unknown Ruby version #{$1}") unless $1 == "1.8" || $1 == "1.9"
+    $1
   end
 
-  module_function :setup_gems
+  def jruby_mode_token(ruby_version = nil)
+    version_map = {"1.8" => "RUBY1_8", "--1.8" => "RUBY1_8", "1.9" => "RUBY1_9", "--1.9" => "RUBY1_9"}
+    version_map[ruby_version.to_s] || version_map[RedStorm.current_ruby_mode]
+  end
+
+  module_function :current_ruby_mode, :jruby_mode_token
+
+  # puts("*** LAUNCH_PATH=#{LAUNCH_PATH}")
+  # puts("*** JAR_CONTEXT=#{JAR_CONTEXT}")
+  # puts("*** BASE_PATH=#{BASE_PATH}")
+  # puts("*** REDSTORM_HOME=#{REDSTORM_HOME}")
+  # puts("*** TARGET_PATH=#{TARGET_PATH}")
+  # puts("*** GEM_PATH=#{GEM_PATH}") if defined?(GEM_PATH)
 end

data/lib/red_storm/simple_topology.rb

@@ -1,3 +1,4 @@
+require 'java'
 require 'red_storm/configuration'
 require 'red_storm/configurator'
 
@@ -56,6 +57,8 @@ module RedStorm
             declarer.globalGrouping(source_id)
           when :shuffle
             declarer.shuffleGrouping(source_id)
+          when :local_or_shuffle
+            declarer.localOrShuffleGrouping(source_id)
           when :none
             declarer.noneGrouping(source_id)
           when :all
@@ -109,28 +112,23 @@ module RedStorm
 
       builder = TopologyBuilder.new
       self.class.spouts.each do |spout|
-        declarer = builder.setSpout(spout.id, spout.new_instance(base_class_path), spout.parallelism)
+        declarer = builder.setSpout(spout.id, spout.new_instance(base_class_path), spout.parallelism.to_java)
         declarer.addConfigurations(spout.config)
       end
       self.class.bolts.each do |bolt|
-        declarer = builder.setBolt(bolt.id, bolt.new_instance(base_class_path), bolt.parallelism)
+        declarer = builder.setBolt(bolt.id, bolt.new_instance(base_class_path), bolt.parallelism.to_java)
         declarer.addConfigurations(bolt.config)
         bolt.define_grouping(declarer)
       end
 
-      configurator = Configurator.new
+      # set the JRuby compatibility mode option for Storm workers, default to current JRuby mode
+      defaults = {"topology.worker.childopts" => "-Djruby.compat.version=#{RedStorm.jruby_mode_token}"}
+
+      configurator = Configurator.new(defaults)
       configurator.instance_exec(env, &self.class.configure_block)
  
-      case env
-      when :local
-        @cluster = LocalCluster.new
-        @cluster.submitTopology(self.class.topology_name, configurator.config, builder.createTopology)
-      when :cluster
-        StormSubmitter.submitTopology(self.class.topology_name, configurator.config, builder.createTopology);
-      else
-        raise("unsupported env=#{env.inspect}, expecting :local or :cluster")
-      end
-
+      submitter = (env == :local) ? @cluster = LocalCluster.new : StormSubmitter
+      submitter.submitTopology(self.class.topology_name, configurator.config, builder.createTopology)
       instance_exec(env, &self.class.submit_block)
     end
 

data/lib/red_storm/topology_launcher.rb

@@ -17,33 +17,12 @@ java_import 'redstorm.storm.jruby.JRubySpout'
 
 java_package 'redstorm'
 
-# setup some environment constants
-# this is required here and in red_storm.rb which are both 
-# entry points in redstorm. 
-module RedStorm
-  LAUNCH_PATH = File.expand_path(File.dirname(__FILE__))
-  JAR_CONTEXT = !!(LAUNCH_PATH =~ /\.jar!$/)
-
-  if JAR_CONTEXT
-    BASE_PATH = LAUNCH_PATH
-    LIB_PATH = "#{BASE_PATH}/lib"
-  else
-    BASE_PATH = Dir.pwd
-    LIB_PATH = "#{BASE_PATH}/target/lib"
-  end
-end
-
 # TopologyLauncher is the application entry point when launching a topology. Basically it will 
 # call require on the specified Ruby topology class file path and call its start method
 class TopologyLauncher
 
   java_signature 'void main(String[])'
   def self.main(args)
-    # this is the entry point for these two contexts:
-    # - runnig a topology in local mode. the current Ruby env will stay the same at topology execution
-    # - submitting a topology in cluster mode. the current Ruby env will be valid only at topology submission. At topology execution
-    #   in the cluster, the new entry point will be the red_storm.rb, topology_launcher will not be called
-
     unless args.size > 1
       puts("Usage: redstorm local|cluster topology_class_file_name")
       exit(1)
@@ -52,11 +31,9 @@ class TopologyLauncher
     env = args[0].to_sym
     class_path = args[1]
 
-    $:.unshift "#{RedStorm::BASE_PATH}"
-    $:.unshift "#{RedStorm::LIB_PATH}"
-
-    require 'red_storm/environment'
-    RedStorm.setup_gems
+    launch_path = Dir.pwd
+    $:.unshift File.expand_path(launch_path)
+    $:.unshift File.expand_path(launch_path + '/lib')
 
     require "#{class_path}" 
 

data/lib/red_storm/version.rb

@@ -1,3 +1,3 @@
 module RedStorm
-  VERSION = '0.5.1'
+  VERSION = '0.6.0'
 end

data/lib/tasks/red_storm.rake

@@ -1,28 +1,20 @@
 require 'ant'
+require 'jruby/jrubyc'
+require 'pompompom'
 require 'red_storm'
-
-# begin
-#   # will work from gem, since lib dir is in gem require_paths
-#   require 'red_storm'
-# rescue LoadError
-#   # will work within RedStorm dev project
-#   $:.unshift './lib'
-#   require 'red_storm'
-# end
  
-INSTALL_STORM_VERSION = "0.7.1"
-INSTALL_JRUBY_VERSION = "1.6.7"
-DEFAULT_GEMFILE = "Gemfile"
+INSTALL_STORM_VERSION = "0.7.3"
+INSTALL_JRUBY_VERSION = "1.6.7.2"
 
 CWD = Dir.pwd
 TARGET_DIR = "#{CWD}/target"
 TARGET_LIB_DIR = "#{TARGET_DIR}/lib"
 TARGET_SRC_DIR = "#{TARGET_DIR}/src"
+TARGET_GEM_DIR = "#{TARGET_DIR}/gems/gems"
+TARGET_SPECS_DIR = "#{TARGET_DIR}/gems/specifications"
 TARGET_CLASSES_DIR = "#{TARGET_DIR}/classes"  
 TARGET_DEPENDENCY_DIR = "#{TARGET_DIR}/dependency"
 TARGET_DEPENDENCY_UNPACKED_DIR = "#{TARGET_DIR}/dependency-unpacked"
-TARGET_MARKERS_DIR = "#{TARGET_DIR}/dependency-markers"
-TARGET_GEMS_DIR = "#{TARGET_DIR}/gems"
 TARGET_CLUSTER_JAR = "#{TARGET_DIR}/cluster-topology.jar"
 
 REDSTORM_JAVA_SRC_DIR = "#{RedStorm::REDSTORM_HOME}/src/main"
@@ -31,13 +23,29 @@ REDSTORM_LIB_DIR = "#{RedStorm::REDSTORM_HOME}/lib"
 SRC_EXAMPLES = "#{RedStorm::REDSTORM_HOME}/examples"
 DST_EXAMPLES = "#{CWD}/examples"
 
-task :launch, :env, :class_file do |t, args|
-  version_token = RedStorm::RUNTIME['RUBY_VERSION'] == "--1.9" ? "RUBY1_9" : "RUBY1_8"
-  # gem_home = ENV["GEM_HOME"].to_s.empty? ? " -Djruby.gem.home=`gem env home`" : ""
-  gem_home = " -Djruby.gem.home=#{RedStorm::GEM_PATH}" 
-  command = "java -Djruby.compat.version=#{version_token} -cp \"#{TARGET_CLASSES_DIR}:#{TARGET_DEPENDENCY_DIR}/*\"#{gem_home} redstorm.TopologyLauncher #{args[:env]} #{args[:class_file]}"
+module JavaZip
+  import 'java.util.zip.ZipFile'
+end
+
+task :launch, :env, :ruby_mode, :class_file do |t, args|
+  # use ruby mode parameter or default to current interpreter version
+  version_token = RedStorm.jruby_mode_token(args[:ruby_mode])
+  
+  command = case args[:env]
+  when "local"
+    "java -Djruby.compat.version=#{version_token} -cp \"#{TARGET_CLASSES_DIR}:#{TARGET_DEPENDENCY_DIR}/*\" redstorm.TopologyLauncher local #{args[:class_file]}"
+  when "cluster"
+    unless File.exist?(TARGET_CLUSTER_JAR)
+      puts("cluster jar file #{TARGET_CLUSTER_JAR} not found. Generate it using $redstorm jar DIR1 [DIR2, ...]")
+      exit(1)
+    end
+    "storm jar #{TARGET_CLUSTER_JAR} -Djruby.compat.version=#{version_token} redstorm.TopologyLauncher cluster #{args[:class_file]}"
+  end
+
   puts("launching #{command}")
-  system(command)
+  unless system(command)
+    puts($!)
+  end
 end
 
 task :clean do
@@ -52,45 +60,53 @@ task :setup do
   puts("\n--> Setting up target directories")
   ant.mkdir :dir => TARGET_DIR 
   ant.mkdir :dir => TARGET_CLASSES_DIR 
+  ant.mkdir :dir => TARGET_DEPENDENCY_DIR
   ant.mkdir :dir => TARGET_SRC_DIR
-  ant.mkdir :dir => TARGET_GEMS_DIR
-  ant.mkdir :dir => "#{TARGET_GEMS_DIR}/gems"
-  ant.mkdir :dir => "#{TARGET_GEMS_DIR}/bundler"
+  ant.mkdir :dir => TARGET_GEM_DIR
+  ant.mkdir :dir => TARGET_SPECS_DIR
   ant.path :id => 'classpath' do  
     fileset :dir => TARGET_DEPENDENCY_DIR  
     fileset :dir => TARGET_CLASSES_DIR  
   end  
 end
 
-task :install => [:deps, :build, :gems] do
+task :install => [:deps, :build] do
   puts("\nRedStorm install completed. All dependencies installed in #{TARGET_DIR}")
 end
 
 task :unpack do
-  system("rmvn dependency:unpack " + \
-         "-f #{RedStorm::REDSTORM_HOME}/pom.xml " + \
-         "-DoutputDirectory=#{TARGET_DEPENDENCY_UNPACKED_DIR} " + \
-         "-DmarkersDirectory=#{TARGET_MARKERS_DIR} " + \
-         "-Dstorm-storm.version=#{INSTALL_STORM_VERSION} " + \
-         "-Dorg.jruby-jruby-complete.version=#{INSTALL_JRUBY_VERSION}")
+  unpack_artifacts = %w[jruby-complete]
+  unpack_glob = "#{TARGET_DEPENDENCY_DIR}/{#{unpack_artifacts.join(',')}}-*-jar.jar"
+  Dir[unpack_glob].each do |jar|
+    puts("Extracting #{jar}")
+    zf = JavaZip::ZipFile.new(jar)
+    zf.entries.each do |entry|
+      next if entry.directory?
+      destination = "#{TARGET_DEPENDENCY_UNPACKED_DIR}/#{entry.name}"
+      in_io = zf.get_input_stream(entry).to_io
+      FileUtils.mkdir_p(File.dirname(destination))
+      File.open(destination, 'w') { |out_io| out_io.write(in_io.read) }
+    end
+  end
 end
 
 task :jar, [:include_dir] => [:unpack, :clean_jar] do |t, args|
   puts("\n--> Generating JAR file #{TARGET_CLUSTER_JAR}")
   ant.jar :destfile => TARGET_CLUSTER_JAR do
-    fileset :dir => TARGET_CLASSES_DIR
     fileset :dir => TARGET_DEPENDENCY_UNPACKED_DIR
-    fileset :dir => TARGET_GEMS_DIR do
-      # remove bundler config dir to avoid setting BUNDLE_PATH
-      exclude :name => "bundler/.bundle/**"
+    fileset :dir => TARGET_DIR do
+      include :name => "gems/**"
     end
+    fileset :dir => TARGET_CLASSES_DIR
     # red_storm.rb and red_storm/* must be in root of jar so that "require 'red_storm'"
     # in bolts/spouts works in jar context
     fileset :dir => TARGET_LIB_DIR do
       exclude :name => "tasks/**"
     end
-    fileset :dir => CWD do
-      args[:include_dir].split(":").each{|dir| include :name => "#{dir}/**/*"}
+    if args[:include_dir]
+      fileset :dir => CWD do
+        args[:include_dir].split(":").each{|dir| include :name => "#{dir}/**/*"}
+      end
     end
     manifest do
       attribute :name => "Main-Class", :value => "redstorm.TopologyLauncher"
@@ -110,25 +126,33 @@ task :examples do
   end
 
   puts("\n--> Installing examples into #{DST_EXAMPLES}")
-  system("mkdir #{DST_EXAMPLES}")
-  system("cp -r #{SRC_EXAMPLES}/* #{DST_EXAMPLES}")
+  FileUtils.mkdir(DST_EXAMPLES)
+  FileUtils.cp_r(Dir["#{SRC_EXAMPLES}/*"], DST_EXAMPLES)
+end
+
+task :copy_red_storm do
+  FileUtils.cp_r(REDSTORM_LIB_DIR, TARGET_DIR)
 end
 
 task :deps => :setup do
   puts("\n--> Installing dependencies")
-  # install maven dependencies in target
-  system("rmvn dependency:copy-dependencies " + \
-         "-f #{RedStorm::REDSTORM_HOME}/pom.xml " + \
-         "-DoutputDirectory=#{TARGET_DEPENDENCY_DIR} " + \
-         "-DmarkersDirectory=#{TARGET_MARKERS_DIR} " + \
-         "-Dstorm-storm.version=#{INSTALL_STORM_VERSION} " + \
-         "-Dorg.jruby-jruby-complete.version=#{INSTALL_JRUBY_VERSION}")
-
-  # copy RedStorm lib dir in target
-  system("cp -r #{REDSTORM_LIB_DIR} #{TARGET_DIR}")
+
+  configuration = {
+    :repositories => {:clojars => 'http://clojars.org/repo/', :sonatype => "http://oss.sonatype.org/content/groups/public/"},
+    :dependencies => [
+      "storm:storm:#{INSTALL_STORM_VERSION}|type_filter=jar",
+      "org.slf4j:slf4j-api:1.5.8|type_filter=jar",
+      "org.slf4j:slf4j-log4j12:1.5.8|type_filter=jar",
+      "org.jruby:jruby-complete:#{INSTALL_JRUBY_VERSION}|transitive=false,type_filter=jar",
+    ],
+    :destination => TARGET_DEPENDENCY_DIR
+  }
+
+  installer = PomPomPom::Runner.new(configuration)
+  installer.run
 end
 
-task :build => :setup do
+task :build => [:setup, :copy_red_storm] do
   # compile the JRuby proxy classes to Java
   build_jruby("#{REDSTORM_LIB_DIR}/red_storm/proxy")
 
@@ -145,46 +169,26 @@ task :build => :setup do
   build_java_dir("#{TARGET_SRC_DIR}")
 end
 
-task :bundle, [:bundler_options] => :gems do |t, args|
-  bundler_options = args[:bundler_options].to_s.split(":").join(" ")
-
-  gemfile = ""
-  if bundler_options.split(" ").size == 1
-    gemfile = bundler_options
-    bundler_options = ""
-  else
-    gemfile = (bundler_options =~ /--gemfile\s+([^\s]+)/) ? $1 : DEFAULT_GEMFILE
-  end
-
-  if bundler_options =~ /--gemfile\s+[^\s]+/
-    bundler_options.gsub!(/--gemfile\s+[^\s]+/, "--gemfile ./Gemfile ")
-  else
-    bundler_options = bundler_options + " --gemfile ./Gemfile"
-  end
-  bundler_options = bundler_options + " --path ./"
-
-  if File.exist?(gemfile)
-    puts("\n--> Bundling gems in #{TARGET_GEMS_DIR}/bundler using #{gemfile}")
-    system("cp #{gemfile} #{TARGET_GEMS_DIR}/bundler/Gemfile")
-    cmd = "(cd #{TARGET_GEMS_DIR}/bundler; " + \
-          "unset BUNDLE_GEMFILE; " + \
-          "unset BUNDLE_PATH; " + \
-          "unset RUBYOPT; " + \
-          "export GEM_PATH=#{RedStorm::GEM_PATH}; " + \
-          "export GEM_HOME=#{RedStorm::GEM_PATH}; " + \
-          "jruby #{RedStorm::RUNTIME['RUBY_VERSION']} -S bundle install #{bundler_options})"
-    system(cmd)
-  elsif gemfile != DEFAULT_GEMFILE
-    puts("WARNING: #{gemfile} not found, cannot bundle gems")
+task :bundle, [:groups] => :setup do |t, args|
+  require 'bundler'
+  args.with_defaults(:groups => 'default')
+  groups = args[:groups].split(':').map(&:to_sym)
+  Bundler.definition.specs_for(groups).each do |spec|
+    unless spec.full_name =~ /^bundler-\d+/
+      destination_path = "#{TARGET_GEM_DIR}/#{spec.full_name}"
+      unless File.directory?(destination_path)
+        puts("installing gem #{spec.full_name} into #{destination_path}")
+        # copy the actual gem dir
+        FileUtils.cp_r(spec.full_gem_path, destination_path)
+        # copy the gemspec into the specifications/ dir
+        FileUtils.cp_r(spec.loaded_from, TARGET_SPECS_DIR)
+        # strip the .git directory from git dependencies, it can be huge
+        FileUtils.rm_rf("#{destination_path}/.git")
+      end
+    end
   end
 end
 
-task :gems => :setup do
-  puts("\n--> Installing base gems in #{TARGET_GEMS_DIR}/gems")
-  system("gem install bundler --install-dir #{TARGET_GEMS_DIR}/gems --no-ri --no-rdoc --quiet --no-verbose")
-  system("gem install rake --install-dir #{TARGET_GEMS_DIR}/gems --no-ri --no-rdoc --quiet --no-verbose")
-end
-
 def build_java_dir(source_folder)
   puts("\n--> Compiling Java")
   ant.javac(
@@ -204,5 +208,14 @@ end
 
 def build_jruby(source_path)
   puts("\n--> Compiling JRuby")
-  system("cd #{RedStorm::REDSTORM_HOME}; jrubyc -t #{TARGET_SRC_DIR} --verbose --java -c \"#{TARGET_DEPENDENCY_DIR}/storm-#{INSTALL_STORM_VERSION}.jar\" -c \"#{TARGET_CLASSES_DIR}\" #{source_path}")
+  Dir.chdir(RedStorm::REDSTORM_HOME) do
+    argv = []
+    argv << '-t' << TARGET_SRC_DIR
+    argv << '--verbose'
+    argv << '--java'
+    argv << '-c' << %("#{TARGET_DEPENDENCY_DIR}/storm-#{INSTALL_STORM_VERSION}.jar")
+    argv << '-c' << %("#{TARGET_CLASSES_DIR}")
+    argv << source_path
+    status =  JRuby::Compiler::compile_argv(argv)
+  end
 end