iron_worker_ng 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Iron.io, Inc
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,34 @@
+# Basic Usage
+
+Visit http://iron.io for more details.
+
+## Create Worker
+
+You can just put any code into worker or can create class with name matching file name (e.g MyWorker class in my_worker.rb) and run method.
+
+```ruby
+require 'active_record'
+
+# @params hash is available here
+# do something fun
+```
+
+## Create Runner
+
+```ruby
+require 'iron_worker_ng'
+
+client = IronWorkerNG::Client.new('IRON_IO_PROJECT_ID', 'IRON_IO_TOKEN')
+
+code = IronWorkerNG::Code::Ruby.new
+code.merge_worker 'path/to/my_worker.rb'
+code.merge_gem 'activerecord'
+
+# you can use hash_string to check if you need to reupload code
+# note that hash_string check is fast while code upload can take a while (depends on how much things you merged)
+puts code.hash_string
+
+client.codes.create(code)
+
+client.tasks.create('MyWorker', 'foo' => 'bar')
+```

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/iron_worker_ng

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'time'
+require 'iron_worker_ng'
+
+if $*.size == 0 || (not ['upload', 'queue', 'schedule'].include?($*[0]))
+  puts 'usage: iron_worker_ng COMMAND [OPTIONS]'
+  puts '    COMMAND: upload, queue, schedule'
+  puts '    run iron_worker_ng COMMAND --help to get more information about each command'
+  exit 1
+end
+
+command = $*[0]
+$*.shift
+
+if ENV['IRON_IO_PROJECT_ID'].nil? || ENV['IRON_IO_TOKEN'].nil?
+  puts "please set $IRON_IO_PROJECT_ID and $IRON_IO_TOKEN environment variables"
+  exit 1
+end
+
+client = IronWorkerNG::Client.new(ENV['IRON_IO_PROJECT_ID'], ENV['IRON_IO_TOKEN'])
+
+if command == 'upload'
+  runtimes = IronWorkerNG::Code::Base.registered_types
+  runtimes_help = runtimes[0][:name] + ' (default)' + (runtimes.size == 1 ? '' : ', ') + runtimes.map { |r| r[:name] }[1 .. -1].join(', ')
+
+  features = []
+
+  name = nil
+  runtime = nil
+  execute_features = []
+
+  opts = OptionParser.new do |opts|
+    opts.banner = 'usage: iron_worker_ng upload [OPTIONS]'
+
+    opts.on('-r', '--runtime RUNTIME', runtimes.map { |r| r[:name] }, "#{runtimes_help}") do |v|
+      runtime = v
+    end
+
+    opts.on('-n', '--name NAME', 'code name') do |v|
+      name = v
+    end
+
+    IronWorkerNG::Code::Base.registered_features.each do |f|
+      prefix = ''
+
+      if f[:for_klass] != IronWorkerNG::Code::Base
+        prefix = runtimes.find { |r| r[:klass] == f[:for_klass] }[:name] + '-'
+      end
+
+      opts.on("--#{prefix}#{f[:name].gsub('_', '-')} #{f[:args]}", Array) do |v|
+        execute_features << {:name => f[:name], :args => v}
+      end
+    end
+  end
+
+  begin
+    opts.parse!
+  rescue OptionParser::ParseError
+    puts $!.to_s
+    exit 1
+  end
+
+  if execute_features.size == 0
+    puts opts
+    exit 1
+  end
+
+  runtime = runtimes[0][:name] if runtime.nil?
+
+  code = runtimes.find { |r| r[:name] == runtime }[:klass].new(name)
+
+  execute_features.each do |f|
+    code.send(f[:name], *f[:args])
+  end
+
+  client.codes.create(code)
+elsif command == 'queue' || command == 'schedule'
+  name = nil
+  params = {}
+
+  priority = nil
+  timeout = nil
+  delay = nil
+
+  start_at = nil
+  end_at = nil
+  run_times = nil
+  run_every = nil
+
+  opts = OptionParser.new do |opts|
+    opts.banner = "usage: iron_worker_ng #{command} [OPTIONS]"
+
+    opts.on('-n', '--name NAME', 'code name') do |v|
+      name = v 
+    end
+
+    opts.on('-p', '--param NAME,VALUE', Array, 'parameters to pass') do |v|
+      params[v[0]] = v[1]
+    end
+
+    opts.on('--priority PRIORITY', Integer, '0 (default), 1, 2') do |v|
+      priority = v
+    end
+
+    opts.on('--timeout TIMEOUT', Integer, 'maximum run time in seconds from 0 to 3600 (default)') do |v|
+      timeout = v
+    end
+
+    opts.on('--delay DELAY', Integer, 'delay before start in seconds') do |v|
+      delay = v
+    end
+
+    if command == 'schedule'
+      opts.on('--start-at TIME', 'start task at specified time') do |v|
+        start_at = Time.parse(v)
+      end
+
+      opts.on('--end-at TIME', 'stop running task at specified time') do |v|
+        end_at = Time.parse(v)
+      end
+
+      opts.on('--run-times RUN_TIMES', Integer, 'run task no more times than specified') do |v|
+        run_times = v
+      end
+
+      opts.on('--run-every RUN_EVERY', Integer, 'run task every RUN_EVERY seconds') do |v|
+        run_every = v
+      end
+    end
+  end
+
+  begin
+    opts.parse!
+  rescue OptionParser::ParseError
+    puts $!.to_s
+    exit 1
+  end
+
+  if name.nil?
+    puts opts
+    exit 1
+  end
+
+  options = {}
+
+  options[:priority] = priority unless priority.nil?
+  options[:timeout] = timeout unless timeout.nil?
+  options[:delay] = delay unless delay.nil?
+
+  if command == 'schedule'
+    options[:start_at] = start_at unless start_at.nil?
+    options[:end_at] = end_at unless end_at.nil?
+    options[:run_times] = run_times unless run_times.nil?
+    options[:run_every] = run_every unless run_every.nil?
+  end
+
+  if command == 'queue'
+    client.tasks.create(name, params, options)
+  else
+    client.schedules.create(name, params, options)
+  end
+end

data/lib/iron_worker_ng.rb

@@ -0,0 +1,6 @@
+require_relative 'iron_worker_ng/version'
+require_relative 'iron_worker_ng/client'
+require_relative 'iron_worker_ng/code/base'
+require_relative 'iron_worker_ng/code/ruby'
+require_relative 'iron_worker_ng/code/java'
+require_relative 'iron_worker_ng/code/node'

data/lib/iron_worker_ng/api_client.rb

@@ -0,0 +1,143 @@
+require 'rest-client'
+require 'rest'
+require 'json'
+require 'time'
+
+require_relative 'api_client_error'
+
+module IronWorkerNG
+  class APIClient
+    attr_reader :project_id
+    attr_reader :token
+
+    def initialize(project_id, token, params = {})
+      @project_id = project_id
+      @token = token
+
+      @user_agent = params[:user_agent] || 'iron_worker_ng-' + IronWorkerNG.version
+
+      scheme = params[:scheme] || 'https'
+      host = params[:host] || 'worker-aws-us-east-1.iron.io'
+      port = params[:port] || 443
+      api_version = params[:api_version] || 2
+
+      @url = "#{scheme}://#{host}:#{port}/#{api_version}/"
+
+      @rest = Rest::Client.new
+    end
+
+    def common_request_hash
+      {
+        'Content-Type' => 'application/json',
+        'Authorization' => "OAuth #{@token}",
+        'User-Agent' => @user_agent
+      }
+    end
+
+    def get(method, params = {})
+      request_hash = {}
+      request_hash[:headers] = common_request_hash
+      request_hash[:params] = params
+
+      @rest.get(@url + method, request_hash)
+    end
+
+    def post(method, params = {})
+      request_hash = {}
+      request_hash[:headers] = common_request_hash
+      request_hash[:body] = params.to_json
+
+      @rest.post(@url + method, request_hash)
+    end
+
+    def delete(method, params = {})
+      request_hash = {}
+      request_hash[:headers] = common_request_hash
+      request_hash[:params] = params
+
+      @rest.delete(@url + method, request_hash)
+    end
+
+    def post_file(method, file, params = {})
+      request_hash = common_request_hash
+      request_hash[:data] = params.to_json
+      request_hash[:file] = file
+
+      RestClient.post(@url + method + "?oauth=#{@token}", request_hash) 
+    end
+
+    def parse_response(response, parse_json = true)
+      raise IronWorkerNG::APIClientError.new(response.body) if response.code != 200
+
+      return response.body unless parse_json
+      JSON.parse(response.body)
+    end
+
+    def codes_list(params = {})
+      parse_response(get("projects/#{@project_id}/codes", params))
+    end
+
+    def codes_get(id)
+      parse_response(get("projects/#{@project_id}/codes/#{id}"))
+    end
+
+    def codes_create(name, file, runtime, runner)
+      parse_response(post_file("projects/#{@project_id}/codes", File.new(file, 'rb'), {:name => name, :runtime => runtime, :file_name => runner}))
+    end
+
+    def codes_delete(id)
+      parse_response(delete("projects/#{@project_id}/codes/#{id}"))
+    end
+
+    def codes_revisions(id, params = {})
+      parse_response(get("projects/#{@project_id}/codes/#{id}/revisions", params))
+    end
+
+    def codes_download(id, params = {})
+      parse_response(get("projects/#{@project_id}/codes/#{id}/download", params), false)
+    end
+
+    def tasks_list(params = {})
+      parse_response(get("projects/#{@project_id}/tasks", params))
+    end
+
+    def tasks_get(id)
+      parse_response(get("projects/#{@project_id}/tasks/#{id}"))
+    end
+
+    def tasks_create(code_name, payload, params = {})
+      parse_response(post("projects/#{@project_id}/tasks", {:tasks => [{:code_name => code_name, :payload => payload}.merge(params)]}))
+    end
+
+    def tasks_cancel(id)
+      parse_response(post("projects/#{@project_id}/tasks/#{id}/cancel"))
+    end
+
+    def tasks_log(id)
+      parse_response(get("projects/#{@project_id}/tasks/#{id}/log"), false)
+    end
+
+    def tasks_set_progress(id, params = {})
+      parse_response(post("projects/#{@project_id}/tasks/#{id}/progress", params))
+    end
+
+    def schedules_list(params = {})
+      parse_response(get("projects/#{@project_id}/schedules", params))
+    end
+
+    def schedules_get(id)
+      parse_response(get("projects/#{@project_id}/schedules/#{id}"))
+    end
+
+    def schedules_create(code_name, payload, params = {})
+      params[:start_at] = params[:start_at].iso8601 if (not params[:start_at].nil?) && params[:start_at].class == Time
+      params[:end_at] = params[:end_at].iso8601 if (not params[:end_at].nil?) && params[:end_at].class == Time
+
+      parse_response(post("projects/#{@project_id}/schedules", {:schedules => [{:code_name => code_name, :payload => payload}.merge(params)]}))
+    end
+
+    def schedules_cancel(id)
+      parse_response(post("projects/#{@project_id}/schedules/#{id}/cancel"))
+    end
+  end
+end

data/lib/iron_worker_ng/api_client_error.rb

@@ -0,0 +1,4 @@
+module IronWorkerNG
+  class APIClientError < Exception
+  end
+end

data/lib/iron_worker_ng/client.rb

@@ -0,0 +1,55 @@
+require_relative 'api_client'
+
+module IronWorkerNG
+  class ClientProxyCaller
+    def initialize(client, prefix)
+      @client = client
+      @prefix = prefix
+    end
+
+    def method_missing(name, *args, &block)
+      full_name = @prefix.to_s + '_' + name.to_s
+      if @client.respond_to?(full_name)
+        @client.send(full_name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  class Client
+    attr_reader :api
+
+    def initialize(project_id, token, params = {})
+      @api = IronWorkerNG::APIClient.new(project_id, token, params)
+    end
+
+    def method_missing(name, *args, &block)
+      if args.length == 0
+        IronWorkerNG::ClientProxyCaller.new(self, name)
+      else
+        super
+      end
+    end
+
+    def codes_create(code)
+      zip_file = code.create_zip
+      @api.codes_create(code.name, zip_file, code.runtime, code.runner)
+      File.unlink(zip_file)
+
+      true
+    end
+
+    def tasks_create(code_name, params = {}, options = {})
+      res = @api.tasks_create(code_name, {:project_id => @api.project_id, :token => @api.token, :params => params}.to_json, options)
+
+      res['tasks'][0]['id']
+    end
+
+    def schedules_create(code_name, params = {}, options = {})
+      res = @api.schedules_create(code_name, {:project_id => @api.project_id, :token => @api.token, :params => params}.to_json, options)
+
+      res['schedules'][0]['id']
+    end
+  end
+end

data/lib/iron_worker_ng/code/base.rb

@@ -0,0 +1,95 @@
+require 'tmpdir'
+require 'zip/zip'
+
+require_relative '../feature/base'
+require_relative '../feature/common/merge_file'
+require_relative '../feature/common/merge_dir'
+
+module IronWorkerNG
+  module Code
+    class Base
+      attr_reader :name
+      attr_reader :features
+
+      @@registered_types = []
+    
+      def self.registered_types
+        @@registered_types
+      end
+    
+      def self.register_type(type)
+        @@registered_types << type
+      end
+
+      @@registered_features = []
+    
+      def self.registered_features
+        @@registered_features
+      end
+    
+      def self.register_feature(feature)
+        @@registered_features << feature
+      end
+
+      include IronWorkerNG::Feature::Common::MergeFile::InstanceMethods
+      include IronWorkerNG::Feature::Common::MergeDir::InstanceMethods
+
+      def initialize(name = nil)
+        @name = name
+        @features = []
+      end
+
+      def fixate
+        IronWorkerNG::Code::Base.registered_features.each do |rf|
+          if rf[:for_klass] == self.class && respond_to?(rf[:name] + '_fixate')
+            send(rf[:name] + '_fixate')
+          end
+        end
+      end
+
+      def hash_string
+        fixate
+
+        Digest::MD5.hexdigest(@features.map { |f| f.hash_string }.join)
+      end
+
+      def bundle(zip)
+        @features.each do |feature|
+          feature.bundle(zip)
+        end
+      end
+
+      def create_zip
+        fixate
+
+        init_code = ''
+
+        @features.each do |f|
+          if f.respond_to?(:code_for_init)
+            init_code += f.send(:code_for_init) + "\n"
+          end
+        end
+
+        zip_name = Dir.tmpdir + '/' + Dir::Tmpname.make_tmpname("iron-worker-ng-", "code.zip")
+      
+        Zip::ZipFile.open(zip_name, Zip::ZipFile::CREATE) do |zip|
+          bundle(zip)
+          create_runner(zip, init_code)
+        end
+
+        zip_name
+      end
+
+      def create_runner(zip)
+      end
+
+      def runtime
+        nil
+      end
+
+      def runner
+        nil
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/code/java.rb

@@ -0,0 +1,51 @@
+require_relative '../feature/java/merge_jar'
+require_relative '../feature/java/merge_worker'
+
+module IronWorkerNG
+  module Code
+    class Java < IronWorkerNG::Code::Base
+      include IronWorkerNG::Feature::Java::MergeJar::InstanceMethods
+      include IronWorkerNG::Feature::Java::MergeWorker::InstanceMethods
+
+      def create_runner(zip, init_code)
+        classpath_array = []
+      
+        @features.each do |f|
+          if f.respond_to?(:code_for_classpath)
+            classpath_array << f.send(:code_for_classpath)
+          end
+        end
+
+        classpath = classpath_array.join(':')
+      
+        zip.get_output_stream('runner.rb') do |runner|
+          runner.write <<RUNNER
+# iron_worker_ng-#{IronWorkerNG.version}
+
+root = nil
+
+($*.length - 2).downto(0) do |i|
+  root = $*[i + 1] if $*[i] == '-d'
+end
+
+Dir.chdir(root)
+
+#{init_code}
+
+puts `java -cp #{classpath} #{worker.klass} \#{$*.join(' ')}`
+RUNNER
+        end
+      end
+
+      def runtime
+        'ruby'
+      end
+
+      def runner
+        'runner.rb'
+      end
+    end
+  end
+end
+
+IronWorkerNG::Code::Base.register_type(:name => 'java', :klass => IronWorkerNG::Code::Java)

data/lib/iron_worker_ng/code/node.rb

@@ -0,0 +1,39 @@
+require_relative '../feature/node/merge_worker'
+
+module IronWorkerNG
+  module Code
+    class Node < IronWorkerNG::Code::Base
+      include IronWorkerNG::Feature::Node::MergeWorker::InstanceMethods
+
+      def create_runner(zip, init_code)
+        zip.get_output_stream('runner.rb') do |runner|
+          runner.write <<RUNNER
+# iron_worker_ng-#{IronWorkerNG.version}
+
+root = nil
+
+($*.length - 2).downto(0) do |i|
+  root = $*[i + 1] if $*[i] == '-d'
+end
+
+Dir.chdir(root)
+
+#{init_code}
+
+puts `node \#{worker_file_name} \#{$*.join(' ')}`
+RUNNER
+        end
+      end
+
+      def runtime
+        'ruby'
+      end
+
+      def runner
+        'runner.rb'
+      end
+    end
+  end
+end
+
+IronWorkerNG::Code::Base.register_type(:name => 'node', :klass => IronWorkerNG::Code::Node)

data/lib/iron_worker_ng/code/ruby.rb

@@ -0,0 +1,86 @@
+require_relative '../feature/ruby/merge_gem'
+require_relative '../feature/ruby/merge_gemfile'
+require_relative '../feature/ruby/merge_worker'
+
+module IronWorkerNG
+  module Code
+    class Ruby < IronWorkerNG::Code::Base
+      include IronWorkerNG::Feature::Ruby::MergeGem::InstanceMethods
+      include IronWorkerNG::Feature::Ruby::MergeGemfile::InstanceMethods
+      include IronWorkerNG::Feature::Ruby::MergeWorker::InstanceMethods
+
+      def create_runner(zip, init_code)
+        zip.get_output_stream('runner.rb') do |runner|
+          runner.write <<RUNNER
+# iron_worker_ng-#{IronWorkerNG.version}
+
+root = nil
+payload_file = nil
+task_id = nil
+
+($*.length - 2).downto(0) do |i|
+  root = $*[i + 1] if $*[i] == '-d'
+  payload_file = $*[i + 1] if $*[i] == '-payload'
+  task_id = $*[i + 1] if $*[i] == '-id'
+end
+
+Dir.chdir(root)
+
+#{init_code}
+$:.unshift("\#{root}")
+
+def log(*args)
+  puts *args
+end
+
+require 'json'
+
+payload = JSON.load(File.open(payload_file))
+
+@iron_io_project_id = payload['project_id']
+@iron_io_token = payload['token']
+@iron_worker_task_id = task_id
+@params = payload['params']
+
+require worker_file_name
+
+worker_class = nil
+
+begin
+  worker_class = Kernel.const_get(worker_class_name)
+rescue
+end
+
+unless worker_class.nil?
+  worker_inst = worker_class.new
+
+  class << worker_inst
+    attr_accessor :iron_io_project_id
+    attr_accessor :iron_io_token
+    attr_accessor :iron_worker_task_id
+    attr_accessor :params
+  end
+
+  worker_inst.iron_io_project_id = @iron_io_project_id
+  worker_inst.iron_io_token = @iron_io_token
+  worker_inst.iron_worker_task_id = @iron_worker_task_id
+  worker_inst.params = @params
+
+  worker_inst.run
+end
+RUNNER
+        end
+      end
+
+      def runtime
+        'ruby'
+      end
+
+      def runner
+        'runner.rb'
+      end
+    end
+  end
+end
+
+IronWorkerNG::Code::Base.register_type(:name => 'ruby', :klass => IronWorkerNG::Code::Ruby)

data/lib/iron_worker_ng/feature/base.rb

@@ -0,0 +1,12 @@
+module IronWorkerNG
+  module Feature
+    class Base
+      def hash_string
+        ''
+      end
+
+      def bundle(zip)
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/common/merge_dir.rb

@@ -0,0 +1,43 @@
+module IronWorkerNG
+  module Feature
+    module Common
+      module MergeDir
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+          attr_reader :dest
+
+          def initialize(path, dest)
+            @path = File.expand_path(path)
+            @dest = dest
+          end
+
+          def hash_string
+            s = @path + @dest + File.mtime(@path).to_i.to_s
+
+            Dir.glob(@path + '/**/**') do |path|
+              s += path + File.mtime(path).to_i.to_s
+            end
+
+            Digest::MD5.hexdigest(s)
+          end
+
+          def bundle(zip)
+            Dir.glob(@path + '/**/**') do |path|
+              zip.add(@dest + '/' + File.basename(@path) + path[@path.length .. -1], path)
+            end
+          end
+        end
+
+        module InstanceMethods
+          def merge_dir(path, dest = '.')
+            @features << IronWorkerNG::Feature::Common::MergeDir::Feature.new(path, dest)
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_dir', :for_klass => base, :args => 'PATH[,DEST]')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/common/merge_file.rb

@@ -0,0 +1,35 @@
+module IronWorkerNG
+  module Feature
+    module Common
+      module MergeFile
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+          attr_reader :dest
+
+          def initialize(path, dest)
+            @path = File.expand_path(path)
+            @dest = dest
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + @dest + File.mtime(@path).to_i.to_s)
+          end
+
+          def bundle(zip)
+            zip.add(@dest + '/' + File.basename(@path), @path)
+          end
+        end
+
+        module InstanceMethods
+          def merge_file(path, dest = '.')
+            @features << IronWorkerNG::Feature::Common::MergerFile::Feature.new(path, dest)
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_file', :for_klass => base, :args => 'PATH[,DEST]')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/java/merge_jar.rb

@@ -0,0 +1,37 @@
+module IronWorkerNG
+  module Feature
+    module Java
+      module MergeJar
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+
+          def initialize(path)
+            @path = File.expand_path(path)
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + File.mtime(@path).to_i.to_s)
+          end
+
+          def bundle(zip)
+            zip.add(File.basename(@path), @path)
+          end
+
+          def code_for_classpath
+            File.basename(@path)
+          end
+        end
+
+        module InstanceMethods
+          def merge_jar(path)
+            @features << IronWorkerNG::Feature::Java::MergeJar::Feature.new(path)
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_jar', :for_klass => base, :args => 'PATH')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/java/merge_worker.rb

@@ -0,0 +1,48 @@
+module IronWorkerNG
+  module Feature
+    module Java
+      module MergeWorker
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+          attr_reader :klass
+
+          def initialize(path, klass)
+            @path = File.expand_path(path)
+            @klass = klass
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + @klass + File.mtime(@path).to_i.to_s)
+          end
+
+          def bundle(zip)
+            zip.add(File.basename(@path), @path)
+          end
+
+          def code_for_classpath
+            File.basename(@path)
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :worker
+
+          def merge_worker(path, klass)
+            @worker ||= nil 
+
+            return unless @worker.nil?
+
+            @name ||= klass.split('.')[-1]
+
+            @worker = IronWorkerNG::Feature::Java::MergeWorker::Feature.new(path, klass)
+            @features << @worker
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_worker', :for_klass => base, :args => 'PATH,CLASS')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/node/merge_worker.rb

@@ -0,0 +1,46 @@
+module IronWorkerNG
+  module Feature
+    module Node
+      module MergeWorker
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+
+          def initialize(path)
+            @path = File.expand_path(path)
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + File.mtime(@path).to_i.to_s)
+          end
+
+          def bundle(zip)
+            zip.add(File.basename(@path), @path)
+          end
+
+          def code_for_init
+            "worker_file_name = '#{File.basename(@path)}'"
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :worker
+
+          def merge_worker(path)
+            @worker ||= nil 
+
+            return unless @worker.nil?
+
+            @name ||= File.basename(path).gsub(/\.js$/, '').capitalize.gsub(/_./) { |x| x[1].upcase }
+
+            @worker = IronWorkerNG::Feature::Node::MergeWorker::Feature.new(path)
+            @features << @worker
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_worker', :for_klass => base, :args => 'PATH')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/ruby/merge_gem.rb

@@ -0,0 +1,71 @@
+require 'bundler'
+
+module IronWorkerNG
+  module Feature
+    module Ruby
+      module MergeGem
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :spec
+
+          def initialize(spec)
+            @spec = spec
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@spec.full_name)
+          end
+
+          def bundle(zip)
+            if @spec.extensions.length == 0
+              zip.add('./gems/' + @spec.full_name, @spec.full_gem_path)
+              Dir.glob(@spec.full_gem_path + '/**/**') do |path|
+                zip.add('./gems/' + @spec.full_name + path[@spec.full_gem_path.length .. -1], path)
+              end
+            end
+          end
+
+          def code_for_init
+            if @spec.extensions.length == 0
+              '$:.unshift("#{root}/gems/' + @spec.full_name + '/lib")'
+            else
+              '# native gem ' + @spec.full_name
+            end
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :merge_gem_reqs
+
+          def merge_gem(name, version = '>= 0')
+            @merge_gem_reqs ||= []
+
+            @merge_gem_reqs << Bundler::Dependency.new(name, version.split(', '))
+          end
+
+          def merge_gem_fixate
+            @merge_gem_reqs ||= []
+
+            @features.reject! { |f| f.class == IronWorkerNG::Feature::Ruby::MergeGem::Feature }
+
+            if @merge_gem_reqs.length > 0
+              reqs = @merge_gem_reqs.map { |req| Bundler::DepProxy.new(req, Gem::Platform::RUBY) }
+
+              source = Bundler::Source::Rubygems.new
+              index = Bundler::Index.build { |index| index.use source.specs }
+
+              spec_set = Bundler::Resolver.resolve(reqs, index)
+
+              spec_set.to_a.each do |spec|
+                @features << IronWorkerNG::Feature::Ruby::MergeGem::Feature.new(spec.__materialize__)
+              end
+            end
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_gem', :for_klass => base, :args => 'NAME[,VERSION]')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/ruby/merge_gemfile.rb

@@ -0,0 +1,42 @@
+require 'bundler'
+
+module IronWorkerNG
+  module Feature
+    module Ruby
+      module MergeGemfile
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+          attr_reader :groups
+
+          def initialize(path, groups)
+            @path = File.expand_path(path)
+            @groups = groups
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + File.mtime(@path).to_i.to_s + (File.exists?(@path + '.lock') ? File.mtime(@path + '.lock').to_i.to_s : '') + @groups.join)
+          end
+        end
+
+        module InstanceMethods
+          def merge_gemfile(path, *groups)
+            groups = groups.map { |g| g.to_sym }
+            groups << :default if groups.length == 0
+
+            specs = Bundler::Definition.build(path, path + '.lock', nil).specs_for(groups)
+
+            specs.each do |spec|
+              merge_gem(spec.name, spec.version.to_s)
+            end
+
+            @features << IronWorkerNG::Feature::Ruby::MergeGemfile::Feature.new(path, groups)
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_gemfile', :for_klass => base, :args => 'PATH[,GROUP...]')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/feature/ruby/merge_worker.rb

@@ -0,0 +1,52 @@
+module IronWorkerNG
+  module Feature
+    module Ruby
+      module MergeWorker
+        class Feature < IronWorkerNG::Feature::Base
+          attr_reader :path
+          attr_reader :klass
+
+          def initialize(path, klass)
+            @path = File.expand_path(path)
+            @klass = klass
+          end
+
+          def hash_string
+            Digest::MD5.hexdigest(@path + @klass)
+          end
+
+          def bundle(zip)
+            zip.add('./' + File.basename(@path), @path)
+          end
+
+          def code_for_init
+            "worker_file_name = '#{File.basename(@path)}'\nworker_class_name='#{@klass}'"
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :worker
+
+          def merge_worker(path, klass = nil)
+            @worker ||= nil 
+
+            return unless @worker.nil?
+
+            if klass == nil
+              klass = File.basename(path).gsub(/\.rb$/, '').capitalize.gsub(/_./) { |x| x[1].upcase }
+            end
+
+            @name ||= klass
+
+            @worker = IronWorkerNG::Feature::Ruby::MergeWorker::Feature.new(path, klass)
+            @features << @worker
+          end
+
+          def self.included(base)
+            IronWorkerNG::Code::Base.register_feature(:name => 'merge_worker', :for_klass => base, :args => 'PATH[,CLASS]')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iron_worker_ng/version.rb

@@ -0,0 +1,7 @@
+module IronWorkerNG
+  @@version = nil
+
+  def self.version
+    @@version ||= File.read(File.dirname(__FILE__) + '/../../VERSION').strip
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: iron_worker_ng
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Kirilenko
+- Iron.io, Inc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zip
+  requirement: &79402670 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79402670
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &79402330 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79402330
+- !ruby/object:Gem::Dependency
+  name: rest
+  requirement: &79401930 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79401930
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &79401450 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *79401450
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &79401140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *79401140
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &79400870 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *79400870
+description: New generation ruby client for IronWorker
+email: info@iron.io
+executables:
+- iron_worker_ng
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- VERSION
+- bin/iron_worker_ng
+- lib/iron_worker_ng.rb
+- lib/iron_worker_ng/api_client.rb
+- lib/iron_worker_ng/api_client_error.rb
+- lib/iron_worker_ng/client.rb
+- lib/iron_worker_ng/code/base.rb
+- lib/iron_worker_ng/code/java.rb
+- lib/iron_worker_ng/code/node.rb
+- lib/iron_worker_ng/code/ruby.rb
+- lib/iron_worker_ng/feature/base.rb
+- lib/iron_worker_ng/feature/common/merge_dir.rb
+- lib/iron_worker_ng/feature/common/merge_file.rb
+- lib/iron_worker_ng/feature/java/merge_jar.rb
+- lib/iron_worker_ng/feature/java/merge_worker.rb
+- lib/iron_worker_ng/feature/node/merge_worker.rb
+- lib/iron_worker_ng/feature/ruby/merge_gem.rb
+- lib/iron_worker_ng/feature/ruby/merge_gemfile.rb
+- lib/iron_worker_ng/feature/ruby/merge_worker.rb
+- lib/iron_worker_ng/version.rb
+homepage: http://www.iron.io
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 745459379
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: New generation ruby client for IronWorker
+test_files: []