iron_worker_ng 0.1.8 → 0.1.9

data/README.md

@@ -1,47 +1,184 @@
-# Basic Usage
+# Introduction
 
-Visit http://iron.io for more details.
+To run your code in cloud you need to do two things - upload code package to be executed and queue or schedule it for execution. While you can use REST APIs for that, it's always better to use IronWorker library created specificaly for your language of choice such as IronWorkerNG.
 
-## Create Worker
+# Preparing Environment
 
-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.
+You'll need to register at http://iron.io and get your credintials to use IronWorkerNG. Each account can have unlimited number of project, so take advantage of it by creating separate projects for development, testing and production. Each project is identified by unique project_id and requiers access token to do any actions on it like uploading or queueing workers.
 
-```ruby
-require 'active_record' # just in case
+Also you'll need working ruby 1.9 interpreter and IronWorkerNG gem. Install it using following command.
+
+```sh
+gem install iron_worker_ng
+```
+
+It's recommended that you'll install typhoeus gem as well for faster API interaction.
 
-# do something fun
-puts params[:foo]
+```sh
+gem install typhoeus
+```
+
+# Creating Worker
+
+IronWorkerNG ruby worker is common ruby code. It can be as simple as show below and as complex as you want.
+
+```ruby
+puts "I'm worker"
+puts "My task_id is #{@iron_worker_task_id}"
+puts "I'm executing inside #{@iron_io_project_id} and was queued using #{@iron_io_token} token"
+puts "I got '#{params}' parameters"
 ```
 
-## Create Runner
+Everything your worker will output to stdout will be logged and available for your review when worker will finish execution.
+
+# Create Code Package
+
+As this code will be executed on the cloud, you'll need to supply it with all necessary gems and supplementary data. IronWorkerNG::Code::Ruby will help you to do this.
 
 ```ruby
-require 'iron_worker_ng'
+code = IronWorkerNG::Code::Ruby.new
+
+code.merge_worker 'my_worker.rb'
+code.merge_file '../lib/utils.rb'
+code.merge_dir '../config'
+code.merge_gem 'activerecord'
+```
+
+## IronWorkerNG::Code::Ruby API
 
-client = IronWorkerNG::Client.new('IRON_IO_TOKEN', 'IRON_IO_PROJECT_ID')
+Please note that this API will help you to create code package but to upload it to IronWorker servers you'll need to use IronWorkerNG::Client API.
 
+### initialize(name = nil)
+
+Will create new code package with specified name. If name is omited, camel-cased worker's file name will be used.
+
+```ruby
 code = IronWorkerNG::Code::Ruby.new
-code.merge_worker 'path/to/my_worker.rb'
-code.merge_gem 'activerecord' # we are using it in our worker
+code_with_name = IronWorkerNG::Code::Ruby.new('CoolWorker')
+```
+
+### name()
 
-# 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)
+Will return code package name.
+
+```ruby
+puts code.name
+```
+
+### hash_string()
+
+```
 puts code.hash_string
+```
+
+Will return code package hash string. If you want prevent uploading unchanged code packages, you can use it to check if any changes were made. As it's verty efficient, it shouldn't cause any performace impact.
+
+### merge_file(path, dest = '')
+
+```ruby
+code.merge_file '../config/database.yml' # will be in the same directory as worker
+code.merge_file 'clients.csv', 'information/clients' # will be in information/clients subdirectory
+```
+
+Merges file located at path into the code package. You can use optional dest to set destination directory which will be automatically created.
+
+### merge_dir(path, dest = '')
+
+Recursively merges directory located at path into the code package. 
+
+```ruby
+code.merge_dir '../config' # will be in the same directory as worker
+code.merge_dir 'lib', 'utils' # will be in utils subdirectory, accessible as utils/lib
+```
+
+### merge_worker(path, name = nil)
+
+Merges worker located at path. If name is omited, camel-cased file name will be used. You can have only one worker merged per code package.
+
+```ruby
+code.merge_worker 'my_worker.rb' # name will be MyWorker
+```
+
+### merge_gem(name, version = '>= 0')
+
+Merges gem with dependencies. Please note that gems which contains binary extensions will not be merged at the moment, however we have sane set of such gems preinstalled at IronWorker servers. You can use version constrains if you need specific gem version.
+
+```ruby
+code.merge_gem 'activerecord'
+code.merge_gem 'paperclip', '< 3.0.0,>= 2.1.0'
+```
+
+### merge_gemfile(path, *groups)
+
+Merges all gems from specified groups in Gemfile. Please note that it'll just merge gems and not auto require them when executing worker.
+
+```ruby
+code.merge_gemfile '../Gemfile', 'common', 'worker' # merges gems from common and worker groups
+```
+
+# Using IronWorker
+
+When you have your code package you are ready to run it on IronWorker servers.
+
+```ruby
+client = IronWorkerNG::Client.new(:token => IRON_IO_TOKEN', :project_id => 'IRON_IO_PROJECT_ID')
 
 client.codes.create(code)
+client.tasks.create('MyWorker', {:client => 'Joe'})
+```
+
+## IronWorker::Client API
 
-client.tasks.create('MyWorker', :foo => 'bar')
+You can use IronWorkerNG::Client API to upload code packages, queue tasks, created schedules and more.
+
+### initialize(options = {})
+
+Creates client object used for all interactions with IronWorker servers.
+
+```ruby
+client = IronWorkerNG::Client.new(:token => 'IRON_IO_TOKEN', :project_id => 'IRON_IO_PROJECT_ID')
 ```
 
-## CLI
+### codes.list(options = {})
 
-Iron Worker NG got nice CLI tool bundled. Here is small example how to get your code running in cloud in few seconds.
+Returns array of information about uploaded codes. Visit http://dev.iron.io/worker/reference/api/#list_code_packages for more information about options and code object format.
 
-```sh
-% cat my_worker.rb
-puts "my name is #{params[:name]} and it is #{params[:it]}"
-% iron_worker_ng codes.create --ruby-merge-worker my_worker.rb
-% TASK_ID=`iron_worker_ng tasks.create -n MyWorker -p name,worker -p it,fun --print-id`
-% iron_worker_ng tasks.log -t $TASK_ID --live
-my name is worker and it is fun
+```ruby
+client.codes.list.each do |code|
+  puts code.inspect
+end
+```
+
+### codes.get(code_id)
+
+Returns information about uploaded code with specified code_id. Viist http://dev.iron.io/worker/reference/api/#get_info_about_a_code_package for more information about code object format.
+
+```ruby
+puts client.codes.get('1234567890').name
+```
+
+### codes.create(code)
+
+Uploads IronWorkerNG::Code::Ruby object to IronWorker servers.
+
+```ruby
+client.codes.create(code)
+```
+
+### codes.delete(code_id)
+
+Deletes code with specified code_id from IronWorker servers.
+
+```ruby
+client.codes.delete('1234567890')
+```
+
+### codes.revisions(code_id, options = {})
+
+Returns array of revision information for code package with specified code_id. Visit http://dev.iron.io/worker/reference/api/#list_code_package_revisions for more information about options and revision information object.
+
+```ruby
+client.codes.revisions('1234567890').each do |revision|
+  puts revision.inspect
+end
 ```

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

data/lib/iron_worker_ng/api_client.rb

@@ -17,15 +17,15 @@ module IronWorkerNG
     attr_accessor :api_version
     attr_accessor :user_agent
 
-    def initialize(token, project_id, params = {})
-      @token = token
-      @project_id = project_id
+    def initialize(options = {})
+      @token = options[:token] || options['token']
+      @project_id = options[:project_id] || options['project_id']
 
-      @scheme = params[:scheme] || 'https'
-      @host = params[:host] || IronWorkerNG::APIClient::AWS_US_EAST_HOST
-      @port = params[:port] || 443
-      @api_version = params[:api_version] || 2
-      @user_agent = params[:user_agent] || 'iron_worker_ng-' + IronWorkerNG.version
+      @scheme = options[:scheme] || 'https'
+      @host = options[:host] || IronWorkerNG::APIClient::AWS_US_EAST_HOST
+      @port = options[:port] || 443
+      @api_version = options[:api_version] || 2
+      @user_agent = options[:user_agent] || 'iron_worker_ng-' + IronWorkerNG.version
 
       @url = "#{scheme}://#{host}:#{port}/#{api_version}/"
 
@@ -81,8 +81,8 @@ module IronWorkerNG
       JSON.parse(response.body)
     end
 
-    def codes_list(params = {})
-      parse_response(get("projects/#{@project_id}/codes", params))
+    def codes_list(options = {})
+      parse_response(get("projects/#{@project_id}/codes", options))
     end
 
     def codes_get(id)
@@ -97,24 +97,24 @@ module IronWorkerNG
       parse_response(delete("projects/#{@project_id}/codes/#{id}"))
     end
 
-    def codes_revisions(id, params = {})
-      parse_response(get("projects/#{@project_id}/codes/#{id}/revisions", params))
+    def codes_revisions(id, options = {})
+      parse_response(get("projects/#{@project_id}/codes/#{id}/revisions", options))
     end
 
-    def codes_download(id, params = {})
-      parse_response(get("projects/#{@project_id}/codes/#{id}/download", params), false)
+    def codes_download(id, options = {})
+      parse_response(get("projects/#{@project_id}/codes/#{id}/download", options), false)
     end
 
-    def tasks_list(params = {})
-      parse_response(get("projects/#{@project_id}/tasks", params))
+    def tasks_list(options = {})
+      parse_response(get("projects/#{@project_id}/tasks", options))
     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)]}))
+    def tasks_create(code_name, payload, options = {})
+      parse_response(post("projects/#{@project_id}/tasks", {:tasks => [{:code_name => code_name, :payload => payload}.merge(options)]}))
     end
 
     def tasks_cancel(id)
@@ -129,23 +129,23 @@ module IronWorkerNG
       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))
+    def tasks_set_progress(id, options = {})
+      parse_response(post("projects/#{@project_id}/tasks/#{id}/progress", options))
     end
 
-    def schedules_list(params = {})
-      parse_response(get("projects/#{@project_id}/schedules", params))
+    def schedules_list(options = {})
+      parse_response(get("projects/#{@project_id}/schedules", options))
     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
+    def schedules_create(code_name, payload, options = {})
+      options[:start_at] = options[:start_at].iso8601 if (not options[:start_at].nil?) && options[:start_at].class == Time
+      options[:end_at] = options[:end_at].iso8601 if (not options[:end_at].nil?) && options[:end_at].class == Time
 
-      parse_response(post("projects/#{@project_id}/schedules", {:schedules => [{:code_name => code_name, :payload => payload}.merge(params)]}))
+      parse_response(post("projects/#{@project_id}/schedules", {:schedules => [{:code_name => code_name, :payload => payload}.merge(options)]}))
     end
 
     def schedules_cancel(id)

data/lib/iron_worker_ng/client.rb

@@ -22,8 +22,8 @@ module IronWorkerNG
   class Client
     attr_reader :api
 
-    def initialize(token, project_id, params = {})
-      @api = IronWorkerNG::APIClient.new(token, project_id, params)
+    def initialize(options = {})
+      @api = IronWorkerNG::APIClient.new(options)
     end
 
     def method_missing(name, *args, &block)
@@ -34,8 +34,8 @@ module IronWorkerNG
       end
     end
 
-    def codes_list(params = {})
-      @api.codes_list(params)['codes'].map { |c| OpenStruct.new(c) }
+    def codes_list(options = {})
+      @api.codes_list(options)['codes'].map { |c| OpenStruct.new(c) }
     end
 
     def codes_get(code_id)
@@ -56,20 +56,16 @@ module IronWorkerNG
       true
     end
 
-    def codes_revisions(code_id, params = {})
-      @api.codes_revisions(code_id, params)['revisions'].map { |c| OpenStruct.new(c) }
+    def codes_revisions(code_id, options = {})
+      @api.codes_revisions(code_id, options)['revisions'].map { |c| OpenStruct.new(c) }
     end
 
-    def codes_download(code_id, params = {})
-      @api.codes_download(code_id, params)
+    def codes_download(code_id, options = {})
+      @api.codes_download(code_id, options)
     end
 
-    def tasks_get(task_id)
-      OpenStruct.new(@api.tasks_get(task_id))
-    end
-
-    def tasks_list(params = {})
-      @api.tasks_list(params)['tasks'].map { |t| OpenStruct.new(t) }
+    def tasks_list(options = {})
+      @api.tasks_list(options)['tasks'].map { |t| OpenStruct.new(t) }
     end
 
     def tasks_get(task_id)
@@ -77,7 +73,7 @@ module IronWorkerNG
     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 = @api.tasks_create(code_name, {:token => @api.token, :project_id => @api.project_id, :params => params}.to_json, options)
 
       OpenStruct.new(res['tasks'][0])
     end
@@ -98,25 +94,25 @@ module IronWorkerNG
       @api.tasks_log(task_id)
     end
 
-    def tasks_set_progress(task_id, params = {})
-      @api.tasks_set_progress(task_id, params)
+    def tasks_set_progress(task_id, options = {})
+      @api.tasks_set_progress(task_id, options)
 
       true
     end
 
-    def tasks_wait_for(task_id, params = {})
-      params[:sleep] ||= 5
+    def tasks_wait_for(task_id, options = {})
+      options[:sleep] ||= 5
 
       task = tasks_get(task_id)
       while task.status == 'queued' || task.status == 'running'
         yield task if block_given?
-        sleep params[:sleep]
+        sleep options[:sleep]
         task = tasks_get(task_id)
       end
     end
 
-    def schedules_list(params = {})
-      @api.schedules_list(params)['schedules'].map { |s| OpenStruct.new(s) }
+    def schedules_list(options = {})
+      @api.schedules_list(options)['schedules'].map { |s| OpenStruct.new(s) }
     end
 
     def schedules_get(schedule_id)
@@ -124,7 +120,7 @@ module IronWorkerNG
     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 = @api.schedules_create(code_name, {:token => @api.token, :project_id => @api.project_id, :params => params}.to_json, options)
 
       OpenStruct.new(res['schedules'][0])
     end

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

@@ -12,7 +12,7 @@ module IronWorkerNG
           end
 
           def hash_string
-            Digest::MD5.hexdigest(@path + @klass)
+            Digest::MD5.hexdigest(@path + @klass + File.mtime(@path).to_i.to_s)
           end
 
           def bundle(zip)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron_worker_ng
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-21 00:00:00.000000000 Z
+date: 2012-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zip
@@ -139,7 +139,7 @@ files:
 - 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
+homepage: https://github.com/iron-io/iron_worker_ruby_ng
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -153,7 +153,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 148197165
+      hash: 534011215
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: