simple_worker 0.3.15 → 0.3.16

data/README.markdown

@@ -1,8 +1,10 @@
-Using Simple Worker
-
 Getting Started
 ===============
 
+[Sign up for a SimpleWorker account][1], it's free to try!
+
+[1]: http://www.simpleworker.com/
+
 Configure SimpleWorker
 ----------------------
 
@@ -68,9 +70,43 @@ action in your application. This is almost the same as queuing your worker.
     worker.body = "This is the body"
     **worker.schedule(:start_at=>1.hours.since)**
 
+Check Status
+------------
+
+If you still have access to the worker object, just call:
+
+    worker.status
+
+If you only have the job ID, call:
+
+    SimpleWorker.status(job_id)
+
+This will return a hash like:
+
+     {"task_id"=>"ece460ce-12d8-11e0-8e15-12313b0440c6",
+     "status"=>"running",
+     "msg"=>nil,
+     "start_time"=>"2010-12-28T23:19:36+00:00",
+     "end_time"=>nil,
+     "duration"=>nil,
+     "progress"=>{"percent"=>25}}
+
+TODO: How to access log.
+
+Logging
+-------
+
+    log "Starting to do something..."
+
+
+Setting Progress
+----------------
+
+    set_progress(:percent => progress, :message => "Server running. Trying to connect...")
+
 
 
-Schedule your Worker Recurring
+Schedule a Recurring Job - CRON
 ------------------------------
 
 The alternative is when you want to user it like Cron. In this case you'll probably
@@ -80,6 +116,7 @@ app starts or anything so best to keep it external.
 Create a file called 'schedule_email_worker.rb' and add this:
 
     require 'simple_worker'
+    require_relative 'email_worker'
 
     worker = EmailWorker.new
     worker.to = current_user.email
@@ -92,16 +129,59 @@ Now run it and your worker will be scheduled to run every hour.
 SimpleWorker on Rails
 ---------------------
 
-SimpleWorker only supports Rails 3+.
+Rails 2.X:
 
-Setup:
+    config.gem 'simple_worker'
 
-- Make a workers directory at RAILS_ROOT/app/workers.
-- In application.rb, uncomment config.autoload_paths and put:
+Rails 3.X:
 
-    config.autoload_paths += %W(#{config.paths.app}/workers)
+    gem 'simple_worker'
+
+Now you can use your workers like they're part of your app!  We recommend putting your worker classes in
+/app/workers path.
+
+Configuring a Database Connection
+---------------------------------
+
+Although you could easily do this in your worker, this makes it a bit more convenient and more importantly
+it will create the connection for you. If you are using ActiveRecord, you would add the following to your
+SimpleWorker config:
+
+    config.database = {
+      :adapter => "mysql2",
+      :host => "localhost",
+      :database => "appdb",
+      :username => "appuser",
+      :password => "secret"
+    }
+
+Then before you job is run, SimpleWorker will establish the ActiveRecord connection.
+
+Including/Merging other Ruby Classes
+------------------------------------
+
+If you are using the Rails setup above, you can probably skip this as your models will automatically be merged.
+
+    class AvgWorker < SimpleWorker::Base
+
+        attr_accessor :aws_access_key,
+                      :aws_secret_key,
+                      :s3_suffix
+
+        merge File.join(File.dirname(__FILE__), "..", "app", "models", "user.rb")
+        merge File.join(File.dirname(__FILE__), "..", "app", "models", "account")
+
+Or simpler yet, try using relative paths:
+
+    merge "../app/models/user"
+    merge "../app/models/account.rb"
+
+
+Bringing in other Workers
+---------------------
 
-Now you can use your workers like their part of your app!
+merge_worker
+TODO
 
 
 Configuration Options
@@ -118,7 +198,7 @@ Eg:
     config.global_attributes[:db_user] = "sa"
     config.global_attributes[:db_pass] = "pass"
 
-Then in your worker, you must have:
+Then in your worker, you would have the attributes defined:
 
     attr_accessor :db_user, :db_pass
 

data/lib/rails2_init.rb

@@ -0,0 +1,7 @@
+puts "Initializing list of Rails models..."
+SimpleWorker.configure do |config|
+  path = File.join(Rails.root, 'app/models/*.rb')
+  puts 'path=' + path
+  config.models = Dir.glob(path)
+  puts 'config.models=' + config.models.inspect
+end

data/lib/railtie.rb

@@ -0,0 +1,23 @@
+# see http://api.rubyonrails.org/classes/Rails/Railtie.html
+
+require 'simple_worker'
+require 'rails'
+
+module SimpleWorker
+  class Railtie < Rails::Railtie
+    railtie_name :simple_worker
+
+    initializer "simple_worker.configure_rails_initialization" do |app|
+      puts 'railtie'
+      puts "Initializing list of Rails models..."
+      SimpleWorker.configure do |c2|
+#  path = File.join(File.dirname(caller[0]), '..', 'app/models/*.rb')
+        path = File.join(Rails.root, 'app/models/*.rb')
+        puts 'path=' + path
+        c2.models = Dir.glob(path)
+        puts 'config.models=' + c2.models.inspect
+      end
+
+    end
+  end
+end

data/lib/simple_worker.rb

@@ -1,180 +1,32 @@
 require 'appoxy_api'
 require 'active_support/core_ext'
-require File.join(File.dirname(__FILE__), 'simple_worker', 'base')
-require File.join(File.dirname(__FILE__), 'simple_worker', 'config')
-require File.join(File.dirname(__FILE__), 'simple_worker', 'used_in_worker')
+require_relative 'simple_worker/service'
+require_relative 'simple_worker/base'
+require_relative 'simple_worker/config'
+require_relative 'simple_worker/used_in_worker'
 
 
 module SimpleWorker
 
-    class << self
-        attr_accessor :config,
-                      :service
+  class << self
+    attr_accessor :config,
+                  :service
 
-        def configure()
-            SimpleWorker.config ||= Config.new
-            yield(config)
-            SimpleWorker.service = Service.new(config.access_key, config.secret_key, :config=>config)
-        end
+    def configure()
+      SimpleWorker.config ||= Config.new
+      yield(config)
+      SimpleWorker.service = Service.new(config.access_key, config.secret_key, :config=>config)
     end
-
-    class Service < Appoxy::Api::Client
-
-        attr_accessor :config
-
-        def initialize(access_key, secret_key, options={})
-            puts 'Starting SimpleWorker::Service...'
-            self.config = options[:config] if options[:config]
-            super("http://api.simpleworker.com/api/", access_key, secret_key, options)
-            self.host = self.config.host if self.config && self.config.host
-        end
-
-        # Options:
-        #    - :callback_url
-        #    - :merge => array of files to merge in with this file
-        def upload(filename, class_name, options={})
-
-            # check whether it should upload again
-            tmp = Dir.tmpdir()
-#            puts 'tmp=' + tmp.to_s
-            md5file = "simple_workr_#{class_name.gsub("::", ".")}.md5"
-            existing_md5 = nil
-            f = File.join(tmp, md5file)
-            if File.exists?(f)
-                existing_md5 = IO.read(f)
-#                puts 'existing_md5=' + existing_md5
-            end
-
-            filename = build_merged_file(filename, options[:merge]) if options[:merge]
-
-#            sys.classes[subclass].__file__
-#            puts '__FILE__=' + Base.subclass.__file__.to_s
-            md5 = Digest::MD5.hexdigest(File.read(filename))
-#            puts "new md5=" + md5
-
-            if md5 != existing_md5
-                puts "#{class_name}: new code, so uploading"
-                File.open(f, 'w') { |f| f.write(md5) }
-            else
-                puts "#{class_name}: same code, not uploading"
-            end
-
-            mystring = nil
-            file = File.open(filename, "r") do |f|
-                mystring = f.read
-            end
-            options = {"code"=>mystring, "class_name"=>class_name}
-            ret = post("code/put", options)
-            ret
-        end
-
-        def build_merged_file(filename, merge)
-            merge = merge.dup
-            merge << filename
-            fname2 = File.join(Dir.tmpdir(), File.basename(filename))
-#            puts 'fname2=' + fname2
-#            puts 'merged_file_array=' + merge.inspect
-            File.open(fname2, "w") do |f|
-                merge.each do |m|
-                    f.write File.open(m, 'r') { |mo| mo.read }
-                    f.write "\n\n"
-                end
-            end
-            fname2
-        end
-
-        def add_sw_params(hash_to_send)
-            # todo: remove secret key??  Can use worker service from within a worker without it now
-            hash_to_send["sw_access_key"] = self.access_key
-            hash_to_send["sw_secret_key"] = self.secret_key
-        end
-
-        # class_name: The class name of a previously upload class, eg: MySuperWorker
-        # data: Arbitrary hash of your own data that your task will need to run.
-        def queue(class_name, data={})
-            if !data.is_a?(Array)
-                data = [data]
-            end
-            hash_to_send = {}
-            hash_to_send["payload"] = data
-            hash_to_send["class_name"] = class_name
-            add_sw_params(hash_to_send)
-            if defined?(RAILS_ENV)
-                hash_to_send["rails_env"] = RAILS_ENV
-            end
-            return queue_raw(class_name, hash_to_send)
-
-        end
-
-        def queue_raw(class_name, data={})
-            params = nil
-            hash_to_send = data
-            hash_to_send["class_name"] = class_name
-            ret = post("queue/add", hash_to_send)
-            ret
-
-        end
-
-
-        #
-        # schedule: hash of scheduling options that can include:
-        #     Required:
-        #     - start_at:      Time of first run - DateTime or Time object.
-        #     Optional:
-        #     - run_every:     Time in seconds between runs. If ommitted, task will only run once.
-        #     - delay_type:    Fixed Rate or Fixed Delay. Default is fixed_delay.
-        #     - end_at:        Scheduled task will stop running after this date (optional, if ommitted, runs forever or until cancelled)
-        #     - run_times:     Task will run exactly :run_times. For instance if :run_times is 5, then the task will run 5 times.
-        #
-        def schedule(class_name, data, schedule)
-            raise "Schedule must be a hash." if !schedule.is_a? Hash
-#            if !data.is_a?(Array)
-#                data = [data]
-#            end
-            hash_to_send = {}
-            hash_to_send["payload"] = data
-            hash_to_send["class_name"] = class_name
-            hash_to_send["schedule"] = schedule
-            add_sw_params(hash_to_send)
-#            puts 'about to send ' + hash_to_send.inspect
-            ret = post("scheduler/schedule", hash_to_send)
-            ret
-        end
-
-        def cancel_schedule(scheduled_task_id)
-            raise "Must include a schedule id." if scheduled_task_id.blank?
-            hash_to_send = {}
-            hash_to_send["scheduled_task_id"] = scheduled_task_id
-            ret = post("scheduler/cancel", hash_to_send)
-            ret
-        end
-
-        def get_schedules()
-            hash_to_send = {}
-            ret = get("scheduler/list", hash_to_send)
-            ret
-        end
-
-        def status(task_id)
-            data = {"task_id"=>task_id}
-            ret = get("task/status", data)
-            ret
-        end
-
-        def schedule_status(schedule_id)
-            data = {"schedule_id"=>schedule_id}
-            ret = get("scheduler/status", data)
-            ret
-        end
-
-        def log(task_id)
-            data = {"task_id"=>task_id}
-            ret = get("task/log", data)
-#            puts 'ret=' + ret.inspect
-#            ret["log"] = Base64.decode64(ret["log"])
-            ret
-        end
-
-
-    end
-end
+  end
+
+end
+
+if defined?(Rails)
+  puts 'Rails=' + Rails.inspect
+  puts 'vers=' + Rails::VERSION::MAJOR.inspect
+  if Rails::VERSION::MAJOR == 2
+    require_relative 'rails2_init.rb'
+  else
+    require_relative 'railtie'
+  end
+end

data/lib/simple_worker/base.rb

@@ -4,208 +4,239 @@ require 'digest/md5'
 
 module SimpleWorker
 
-    class Base
+  class Base
 
-        attr_accessor :task_set_id, :task_id, :schedule_id
+    attr_accessor :task_set_id, :task_id, :schedule_id
 
-        class << self
-            attr_accessor :subclass, :caller_file
-            @merged = []
-            @merged_workers = []
+    class << self
+      attr_accessor :subclass, :caller_file
+      @merged         = []
+      @merged_workers = []
 
-            def reset!
-                @merged = []
-                @merged_workers = []
-            end
+      def reset!
+        @merged         = []
+        @merged_workers = []
+      end
 
-            def inherited(subclass)
-                subclass.reset!
+      def inherited(subclass)
+        subclass.reset!
 
 #                puts "subclass.inspect=" + subclass.inspect
 #                puts 'existing caller=' + (subclass.instance_variable_defined?(:@caller_file) ? subclass.instance_variable_get(:@caller_file).inspect : "nil")
 #                puts "caller=" + caller.inspect
 #                splits = caller[0].split(":")
 #                caller_file = splits[0] + ":" + splits[1]
-                caller_file = caller[0][0...(caller[0].index(":in"))]
-                caller_file = caller_file[0...(caller_file.rindex(":"))]
+        caller_file = caller[0][0...(caller[0].index(":in"))]
+        caller_file = caller_file[0...(caller_file.rindex(":"))]
 #                puts 'caller_file=' + caller_file
-                # don't need these class_variables anymore probably
-                subclass.instance_variable_set(:@caller_file, caller_file)
-
-                super
-            end
-
-            # merges the specified files.
-            def merge(*files)
-                files.each do |f|
-                    unless File.exist? f
-                        raise "File not found: " + f
-                    end
-                    require f
-                    @merged << File.expand_path(f)
-                end
+        # don't need these class_variables anymore probably
+        subclass.instance_variable_set(:@caller_file, caller_file)
+
+        super
+      end
+
+      # merges the specified files.
+      # todo: don't allow multiple files per merge, just one like require
+      def merge(*files)
+        files.each do |f|
+          f = f.to_str
+          unless ends_with?(f, ".rb")
+            f << ".rb"
+          end
+          exists = false
+          if File.exist? f
+            exists = true
+          else
+            # try relative
+            f2 = File.join(File.dirname(caller[0]), f)
+            if File.exist? f2
+              exists = true
+              f = f2
             end
-
-            def merge_worker(file, class_name)
-                puts 'merge_worker in ' + self.name
-                merge(file)
-                @merged_workers << [File.expand_path(file), class_name]
-            end
-        end
+          end
+          unless exists
+            raise "File not found: " + f
+          end
+          require f
+          @merged << File.expand_path(f)
+        end
+      end
+
+      def ends_with?(s, suffix)
+        suffix = suffix.to_s
+        s[-suffix.length, suffix.length] == suffix
+      end
+
+      def merge_worker(file, class_name)
+        puts 'merge_worker in ' + self.name
+        merge(file)
+        @merged_workers << [File.expand_path(file), class_name]
+      end
+    end
 
 
-        def log(str)
-            puts str.to_s
-        end
+    def log(str)
+      puts str.to_s
+    end
 
-        def user_dir
-            "."
-        end
+    def user_dir
+      "."
+    end
 
-        def set_progress(hash)
-            puts 'set_progress: ' + hash.inspect
-        end
+    def set_progress(hash)
+      puts 'set_progress: ' + hash.inspect
+    end
 
-        def who_am_i?
-            return self.class.name
-        end
+    def who_am_i?
+      return self.class.name
+    end
 
-        def uploaded?
-            self.class.instance_variable_defined?(:@uploaded) && self.class.instance_variable_get(:@uploaded)
-        end
+    def uploaded?
+      self.class.instance_variable_defined?(:@uploaded) && self.class.instance_variable_get(:@uploaded)
+    end
 
-        # Call this if you want to run locally and get some extra features from this gem like global attributes.
-        def run_local
+    # Call this if you want to run locally and get some extra features from this gem like global attributes.
+    def run_local
 #            puts 'run_local'
-            set_global_attributes
-            run
-        end
+      set_auto_attributes
+      run
+    end
+
+    def set_auto_attributes
+      set_global_attributes
+    end
 
-        def set_global_attributes
-            ga = SimpleWorker.config.global_attributes
-            if ga && ga.size > 0
-                ga.each_pair do |k,v|
+    def set_global_attributes
+      ga = SimpleWorker.config.global_attributes
+      if ga && ga.size > 0
+        ga.each_pair do |k, v|
 #                    puts "k=#{k} v=#{v}"
-                    if self.respond_to?(k)
-                        self.send("#{k}=", v)
-                    end
-                end
-            end
+          if self.respond_to?(k)
+            self.send("#{k}=", v)
+          end
         end
+      end
+    end
 
-        # Will send in all instance_variables.
-        def queue
+    # Will send in all instance_variables.
+    def queue
 #            puts 'in queue'
-            set_global_attributes
-            upload_if_needed
+      set_auto_attributes
+      upload_if_needed
 
-            response = SimpleWorker.service.queue(self.class.name, sw_get_data)
+      response     = SimpleWorker.service.queue(self.class.name, sw_get_data)
 #            puts 'queue response=' + response.inspect
-            @task_set_id = response["task_set_id"]
-            @task_id = response["tasks"][0]["task_id"]
-            response
-        end
+      @task_set_id = response["task_set_id"]
+      @task_id     = response["tasks"][0]["task_id"]
+      response
+    end
 
-        def status
-            SimpleWorker.service.status(task_id)
-        end
+    def status
+      SimpleWorker.service.status(task_id)
+    end
 
-        def upload
-            upload_if_needed
-        end
+    def upload
+      upload_if_needed
+    end
 
-        #
-        # schedule: hash of scheduling options that can include:
-        #     Required:
-        #     - start_at:      Time of first run - DateTime or Time object.
-        #     Optional:
-        #     - run_every:     Time in seconds between runs. If ommitted, task will only run once.
-        #     - delay_type:    Fixed Rate or Fixed Delay. Default is fixed_delay.
-        #     - end_at:        Scheduled task will stop running after this date (optional, if ommitted, runs forever or until cancelled)
-        #     - run_times:     Task will run exactly :run_times. For instance if :run_times is 5, then the task will run 5 times.
-        #
-        def schedule(schedule)
-            set_global_attributes
-            upload_if_needed
-
-            response = SimpleWorker.service.schedule(self.class.name, sw_get_data, schedule)
+    #
+    # schedule: hash of scheduling options that can include:
+    #     Required:
+    #     - start_at:      Time of first run - DateTime or Time object.
+    #     Optional:
+    #     - run_every:     Time in seconds between runs. If ommitted, task will only run once.
+    #     - delay_type:    Fixed Rate or Fixed Delay. Default is fixed_delay.
+    #     - end_at:        Scheduled task will stop running after this date (optional, if ommitted, runs forever or until cancelled)
+    #     - run_times:     Task will run exactly :run_times. For instance if :run_times is 5, then the task will run 5 times.
+    #
+    def schedule(schedule)
+      set_global_attributes
+      upload_if_needed
+
+      response     = SimpleWorker.service.schedule(self.class.name, sw_get_data, schedule)
 #            puts 'schedule response=' + response.inspect
-            @schedule_id = response["schedule_id"]
-            response
-        end
+      @schedule_id = response["schedule_id"]
+      response
+    end
 
-        def schedule_status
-            SimpleWorker.service.schedule_status(schedule_id)
-        end
+    def schedule_status
+      SimpleWorker.service.schedule_status(schedule_id)
+    end
 
-        # Callbacks for developer
-        def before_upload
+    # Callbacks for developer
+    def before_upload
 
-        end
+    end
 
-        def after_upload
+    def after_upload
 
-        end
+    end
 
-        def before_run
+    def before_run
 
-        end
+    end
 
-        def after_run
+    def after_run
 
-        end
+    end
 
-        private
-
-        def upload_if_needed
-
-            before_upload
-
-            puts 'upload_if_needed'
-            # Todo, watch for this file changing or something so we can reupload
-            unless uploaded?
-                subclass = self.class
-                rfile = subclass.instance_variable_get(:@caller_file) # Base.caller_file # File.expand_path(Base.subclass)
-                puts 'rfile=' + rfile.inspect
-                puts 'self.class.name=' + subclass.name
-                merged = self.class.instance_variable_get(:@merged)
-                puts 'merged1=' + merged.inspect
-                superclass = subclass
-                # Also get merged from subclasses up to SimpleWorker::Base
-                while (superclass = superclass.superclass)
-                    puts 'superclass=' + superclass.name
-                    break if superclass.name == SimpleWorker::Base.name
-                    super_merged = superclass.instance_variable_get(:@merged)
+    private
+
+    def upload_if_needed
+
+      before_upload
+
+      puts 'upload_if_needed ' + self.class.name
+      # Todo, watch for this file changing or something so we can reupload
+      unless uploaded?
+        merged = self.class.instance_variable_get(:@merged)
+        puts 'merged1=' + merged.inspect
+
+        subclass = self.class
+        rfile    = subclass.instance_variable_get(:@caller_file) # Base.caller_file # File.expand_path(Base.subclass)
+        puts 'subclass file=' + rfile.inspect
+        puts 'subclass.name=' + subclass.name
+        superclass = subclass
+        # Also get merged from subclasses up to SimpleWorker::Base
+        while (superclass = superclass.superclass)
+          puts 'superclass=' + superclass.name
+          break if superclass.name == SimpleWorker::Base.name
+          super_merged = superclass.instance_variable_get(:@merged)
 #                     puts 'merging caller file: ' + superclass.instance_variable_get(:@caller_file).inspect
-                    super_merged << superclass.instance_variable_get(:@caller_file)
-                    merged = super_merged + merged
-                    puts 'merged with superclass=' + merged.inspect
-
-                end
-                SimpleWorker.service.upload(rfile, subclass.name, :merge=>merged)
-                self.class.instance_variable_set(:@uploaded, true)
-            else
-                puts 'already uploaded for ' + self.class.name
-            end
-            puts 'uploading merged workers'
-            self.class.instance_variable_get(:@merged_workers).each do |mw|
-                # to support merges in the secondary worker, we should instantiate it here, then call "upload"
-                puts 'instantiating and uploading ' + mw[1]
-                Kernel.const_get(mw[1]).new.upload
+          super_merged << superclass.instance_variable_get(:@caller_file)
+          merged = super_merged + merged
+          puts 'merged with superclass=' + merged.inspect
+        end
+        merged += SimpleWorker.config.models if SimpleWorker.config.models
+        SimpleWorker.service.upload(rfile, subclass.name, :merge=>merged)
+        self.class.instance_variable_set(:@uploaded, true)
+      else
+        puts 'already uploaded for ' + self.class.name
+      end
+      merged_workers = self.class.instance_variable_get(:@merged_workers)
+      puts 'now uploading merged WORKERS ' + merged_workers.inspect
+      merged_workers.each do |mw|
+        # to support merges in the secondary worker, we should instantiate it here, then call "upload"
+        puts 'instantiating and uploading ' + mw[1]
+        Kernel.const_get(mw[1]).new.upload
 #                    SimpleWorker.service.upload(mw[0], mw[1])
-            end
+      end
 
-            after_upload
-        end
-
-        def sw_get_data
-            data = {}
-            self.instance_variables.each do |iv|
-                data[iv] = instance_variable_get(iv)
-            end
-            return data
-        end
+      after_upload
+    end
 
+    def sw_get_data
+      data = {}
+      self.instance_variables.each do |iv|
+        data[iv] = instance_variable_get(iv)
+      end
 
+      config_data = {}
+      config_data['database'] = SimpleWorker.config.database if SimpleWorker.config.database
+      data[:sw_config] = config_data
+      return data
     end
+
+
+  end
 end

data/lib/simple_worker/config.rb

@@ -1,21 +1,27 @@
 module SimpleWorker
 
 
-    # Config is used to setup the SimpleWorker client.
-    # You must set the access_key and secret_key.
-    #
-    # config.global_attributes allows you to specify attributes that will automatically be set on every worker,
-    #    this is good for database connection information or things that will be used across the board.
-    class Config
-        attr_accessor :access_key,
-                      :secret_key,
-                      :host,
-                      :global_attributes
+  # Config is used to setup the SimpleWorker client.
+  # You must set the access_key and secret_key.
+  #
+  # config.global_attributes allows you to specify attributes that will automatically be set on every worker,
+  #    this is good for database connection information or things that will be used across the board.
+  #
+  # config.database configures a database connection. If specified like ActiveRecord, SimpleWorker will automatically establish a connection
+  # for you before running your worker.
+  class Config
+    attr_accessor :access_key,
+                  :secret_key,
+                  :host,
+                  :global_attributes,
+                  :models,
+                  :database
 
-        def initialize
-            @global_attributes = {}
-        end
+    def initialize
+      @global_attributes = {}
     end
 
+  end
+
 end
 

data/lib/simple_worker/service.rb

@@ -0,0 +1,170 @@
+module SimpleWorker
+
+  class Service < Appoxy::Api::Client
+
+    attr_accessor :config
+
+    def initialize(access_key, secret_key, options={})
+      puts 'Starting SimpleWorker::Service...'
+      self.config = options[:config] if options[:config]
+      super("http://api.simpleworker.com/api/", access_key, secret_key, options)
+      self.host = self.config.host if self.config && self.config.host
+    end
+
+    # Options:
+    #    - :callback_url
+    #    - :merge => array of files to merge in with this file
+    def upload(filename, class_name, options={})
+      puts "Uploading #{class_name}"
+      # check whether it should upload again
+      tmp          = Dir.tmpdir()
+      md5file      = "simple_worker_#{class_name.gsub("::", ".")}.md5"
+      existing_md5 = nil
+      f            = File.join(tmp, md5file)
+      if File.exists?(f)
+        existing_md5 = IO.read(f)
+      end
+
+      filename = build_merged_file(filename, options[:merge]) if options[:merge]
+
+#            sys.classes[subclass].__file__
+#            puts '__FILE__=' + Base.subclass.__file__.to_s
+      md5      = Digest::MD5.hexdigest(File.read(filename))
+#            puts "new md5=" + md5
+
+      new_code = false
+      if md5 != existing_md5
+        puts "#{class_name}: new code, uploading"
+        File.open(f, 'w') { |f| f.write(md5) }
+        new_code = true
+      else
+        puts "#{class_name}: same code, not uploading"
+      end
+
+      if new_code
+        mystring = nil
+        file     = File.open(filename, "r") do |f|
+          mystring = f.read
+        end
+        options  = {"code"=>mystring, "class_name"=>class_name}
+        ret      = post("code/put", options)
+        ret
+      end
+    end
+
+    def build_merged_file(filename, merge)
+      merge = merge.dup
+      merge << filename
+      merge.uniq!
+      fname2 = File.join(Dir.tmpdir(), File.basename(filename))
+#            puts 'fname2=' + fname2
+#            puts 'merged_file_array=' + merge.inspect
+      File.open(fname2, "w") do |f|
+        merge.each do |m|
+          puts "merging #{m} into #{filename}"
+          f.write File.open(m, 'r') { |mo| mo.read }
+          f.write "\n\n"
+        end
+      end
+      fname2
+    end
+
+    def add_sw_params(hash_to_send)
+      # todo: remove secret key??  Can use worker service from within a worker without it now
+      hash_to_send["sw_access_key"] = self.access_key
+      hash_to_send["sw_secret_key"] = self.secret_key
+    end
+
+    # class_name: The class name of a previously upload class, eg: MySuperWorker
+    # data: Arbitrary hash of your own data that your task will need to run.
+    def queue(class_name, data={})
+      puts "Queuing #{class_name}"
+      if !data.is_a?(Array)
+        data = [data]
+      end
+      p data
+      hash_to_send               = {}
+      hash_to_send["payload"]    = data
+      hash_to_send["class_name"] = class_name
+      add_sw_params(hash_to_send)
+      if defined?(RAILS_ENV)
+        hash_to_send["rails_env"] = RAILS_ENV
+      end
+      return queue_raw(class_name, hash_to_send)
+
+    end
+
+    def queue_raw(class_name, data={})
+      params                     = nil
+      hash_to_send               = data
+      hash_to_send["class_name"] = class_name
+      ret                        = post("queue/add", hash_to_send)
+      ret
+
+    end
+
+
+    #
+    # schedule: hash of scheduling options that can include:
+    #     Required:
+    #     - start_at:      Time of first run - DateTime or Time object.
+    #     Optional:
+    #     - run_every:     Time in seconds between runs. If ommitted, task will only run once.
+    #     - delay_type:    Fixed Rate or Fixed Delay. Default is fixed_delay.
+    #     - end_at:        Scheduled task will stop running after this date (optional, if ommitted, runs forever or until cancelled)
+    #     - run_times:     Task will run exactly :run_times. For instance if :run_times is 5, then the task will run 5 times.
+    #
+    def schedule(class_name, data, schedule)
+      puts "Scheduling #{class_name}"
+      raise "Schedule must be a hash." if !schedule.is_a? Hash
+#            if !data.is_a?(Array)
+#                data = [data]
+#            end
+      hash_to_send               = {}
+      hash_to_send["payload"]    = data
+      hash_to_send["class_name"] = class_name
+      hash_to_send["schedule"]   = schedule
+      add_sw_params(hash_to_send)
+#            puts 'about to send ' + hash_to_send.inspect
+      ret = post("scheduler/schedule", hash_to_send)
+      ret
+    end
+
+    def cancel_schedule(scheduled_task_id)
+      raise "Must include a schedule id." if scheduled_task_id.blank?
+      hash_to_send                      = {}
+      hash_to_send["scheduled_task_id"] = scheduled_task_id
+      ret                               = post("scheduler/cancel", hash_to_send)
+      ret
+    end
+
+    def get_schedules()
+      hash_to_send = {}
+      ret          = get("scheduler/list", hash_to_send)
+      ret
+    end
+
+    def status(task_id)
+      data = {"task_id"=>task_id}
+      ret  = get("task/status", data)
+      ret
+    end
+
+    def schedule_status(schedule_id)
+      data = {"schedule_id"=>schedule_id}
+      ret  = get("scheduler/status", data)
+      ret
+    end
+
+    def log(task_id)
+      data = {"task_id"=>task_id}
+      ret  = get("task/log", data)
+#            puts 'ret=' + ret.inspect
+#            ret["log"] = Base64.decode64(ret["log"])
+      ret
+    end
+
+
+  end
+
+end

data/lib/simple_worker/used_in_worker.rb

@@ -1,3 +1,6 @@
+# UsedInWorker can be included in classes that you are merging in order to get some of the SimpleWorker features into that class.
+# For instance, you can use the log() method and it will be logged to the SimpleWorker logs.
+
 module SimpleWorker
     module UsedInWorker
 

data/test/requiring_worker.rb

@@ -0,0 +1,4 @@
+
+
+require_relative 'models/model_1.rb'
+

data/test/test_base.rb

@@ -1,34 +1,38 @@
 require 'test/unit'
 require 'yaml'
 begin
-    require File.join(File.dirname(__FILE__), '../lib/simple_worker')
+  require File.join(File.dirname(__FILE__), '../lib/simple_worker')
 rescue Exception => ex
-    puts ex.message
-    require 'simple_worker'
+  puts ex.message
+  require 'simple_worker'
 end
-require File.join(File.dirname(__FILE__), "./test_worker")
-require File.join(File.dirname(__FILE__), "./test_worker_2")
-require File.join(File.dirname(__FILE__), "./test_worker_3")
+require_relative "test_worker"
+require_relative "test_worker_2"
+require_relative "test_worker_3"
 
 class TestBase < Test::Unit::TestCase
 
-    def setup
-        @config = YAML::load(File.open(File.expand_path("~/.test-configs/simple_worker.yml")))
-        #puts @config.inspect
-        @access_key = @config['simple_worker']['access_key']
-        @secret_key = @config['simple_worker']['secret_key']
+  def setup
+    @config     = YAML::load(File.open(File.expand_path("~/.test_configs/simple_worker.yml")))
+    #puts @config.inspect
+    @access_key = @config['simple_worker']['access_key']
+    @secret_key = @config['simple_worker']['secret_key']
 
-        @worker = SimpleWorker::Service.new(@access_key, @secret_key)
-        @worker.host = "http://localhost:3000/api/"
+    # new style
+    SimpleWorker.configure do |config|
+      config.access_key                   = @access_key
+      config.secret_key                   = @secret_key
+#            config.host = "http://localhost:3000/api/"
+      config.global_attributes["db_user"] = "sa"
+      config.global_attributes["db_pass"] = "pass"
+      config.database = {
+          :adapter  => "mysql2",
+          :host     => "localhost",
+          :database => "appdb",
+          :username => "appuser",
+          :password => "secret"
+      }
 
-        # new style
-        SimpleWorker.configure do |config|
-            config.access_key = @access_key
-            config.secret_key = @secret_key
-            config.host = "http://localhost:3000/api/"
-            config.global_attributes["db_user"] = "sa"
-            config.global_attributes["db_pass"] = "pass"
-
-        end
     end
+  end
 end

data/test/test_simple_worker.rb

@@ -1,18 +1,16 @@
-
-
 require_relative 'test_base'
 
 class SimpleWorkerTests < TestBase
 
 
-    def test_new_worker_style
-        # Add something to queue, get task ID back
-        tw = TestWorker2.new
-        tw.s3_key = "active style runner"
-        tw.times = 3
-        tw.x = true
+  def test_new_worker_style
+    # Add something to queue, get task ID back
+    tw        = TestWorker2.new
+    tw.s3_key = "active style runner"
+    tw.times  = 3
+    tw.x      = true
 
-        # schedule up a task
+    # schedule up a task
 #        start_at = 10.seconds.since
 #        response_hash_single = tw.schedule(:start_at=>start_at, :run_every=>30, :run_times=>3)
 #        puts 'response_hash=' + response_hash_single.inspect
@@ -21,93 +19,39 @@ class SimpleWorkerTests < TestBase
 #            puts "status #{i}: " + tw.schedule_status.inspect
 #        end
 
-        # queue up a task
-        puts 'queuing ' + tw.inspect
-        response_hash_single = tw.queue
+    # queue up a task
+    puts 'queuing ' + tw.inspect
+    response_hash_single = tw.queue
 
 
-        puts 'response_hash=' + response_hash_single.inspect
-        puts 'task_set_id=' + tw.task_set_id
-        puts 'task_id=' + tw.task_id
-        10.times do |i|
-            puts "status #{i}: " + tw.status.inspect
-            break if tw.status["status"] == "complete"
-            sleep 2
-        end
+    puts 'response_hash=' + response_hash_single.inspect
+    puts 'task_set_id=' + tw.task_set_id
+    puts 'task_id=' + tw.task_id
+    10.times do |i|
+      puts "status #{i}: " + tw.status.inspect
+      break if tw.status["status"] == "complete"
+      sleep 2
+    end
 
-        assert tw.status["status"] == "complete"
+    assert tw.status["status"] == "complete"
 
-    end
+  end
 
-    def test_global_attributes
-        worker = TestWorker3.new
-        worker.run_local
+  def test_global_attributes
+    worker = TestWorker3.new
+    worker.run_local
 
-        puts 'worker=' + worker.inspect
+    puts 'worker=' + worker.inspect
 
-        assert_equal "sa", worker.db_user
-        assert_equal "pass", worker.db_pass
-        assert_equal 123, worker.x
+    assert_equal "sa", worker.db_user
+    assert_equal "pass", worker.db_pass
+    assert_equal 123, worker.x
+
+  end
+
+  def test_require_relative_merge
 
-    end
-#
-#
-#    def test_queue
-#
-#
-#        # Upload latest runner code
-#        @worker.upload(File.join(File.dirname(__FILE__), "./test_worker.rb"), "TestWorker")
-#
-#        # Add something to queue, get task ID back
-#        # Single task
-#        response_hash_single = @worker.queue("TestWorker", {"s3_key"=>"single runner", "times"=>10})
-#
-#        # task set
-#        response_hash = @worker.queue("TestWorker", [{"id"=>"local_id", "s3_key"=>"some key", "times"=>4}, {"s3_key"=>"some key2", "times"=>3}, {"s3_key"=>"some key", "times"=>2}])
-#
-#         # Check status
-#        tasks = response_hash["tasks"]
-#        puts 'tasks.size=' + tasks.size.to_s
-#        while tasks.size > 0
-#            tasks.each do |t|
-#                puts "t=" + t.inspect
-#                status_response = @worker.status(t["task_id"])
-#                puts 'status for ' + t["task_id"] + ' = ' + status_response["status"]
-#                if status_response["status"] == "complete" || status_response["status"] == "error" || status_response["status"] == "cancelled"
-#                    tasks.delete(t)
-#                end
-#            end
-#        end
-#
-#        # lets try to get the log now too
-#        task_id = response_hash_single["tasks"][0]["task_id"]
-#        puts 'task_id=' + task_id
-#        status_with_log = @worker.log(task_id)
-#        puts 'log=' + status_with_log.inspect
-#
-#    end
-#
-#    def test_scheduled
-#
-#        # Upload latest runner code
-#        @worker.upload(File.join(File.dirname(__FILE__), "./scheduled_worker.rb"), "ScheduledWorker")
-#
-#        start_at = 10.seconds.since
-#        #start_at = start_at.gmtime # testing different timezone
-#        puts 'start_at =' + start_at.inspect
-#        response_hash = @worker.schedule("ScheduledWorker", {"msg"=>"One time test."}, {:start_at=>start_at})
-#        puts 'response_hash=' + response_hash.inspect
-#
-#        start_at = 10.seconds.since
-#        response_hash = @worker.schedule("ScheduledWorker", {"msg"=>"Run times test"}, {:start_at=>start_at, :run_every=>30, :run_times=>3})
-#        puts 'response_hash=' + response_hash.inspect
-#
-#        start_at = 10.seconds.since
-#        end_at = 2.minutes.since
-#        response_hash = @worker.schedule("ScheduledWorker", {"msg"=>"End at test"}, {:start_at=>start_at, :run_every=>30, :end_at=>end_at, :run_times=>20})
-#        puts 'response_hash=' + response_hash.inspect
-#
-#    end
 
+  end
 end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 15
-  version: 0.3.15
+  - 16
+  version: 0.3.16
 platform: ruby
 authors: 
 - Travis Reeder
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 -08:00
+date: 2010-12-29 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,12 +39,17 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- lib/rails2_init.rb
+- lib/railtie.rb
 - lib/simple_worker.rb
 - lib/simple_worker/base.rb
 - lib/simple_worker/config.rb
+- lib/simple_worker/service.rb
 - lib/simple_worker/used_in_worker.rb
+- rails/init.rb
 - README.markdown
 - test/models/model_1.rb
+- test/requiring_worker.rb
 - test/scheduled_worker.rb
 - test/second_worker.rb
 - test/test_base.rb
@@ -87,6 +92,7 @@ specification_version: 3
 summary: Classified
 test_files: 
 - test/models/model_1.rb
+- test/requiring_worker.rb
 - test/scheduled_worker.rb
 - test/second_worker.rb
 - test/test_base.rb