simple_worker 0.7.4 → 1.0.0.beta

data/README.markdown

@@ -1,3 +1,12 @@
+KNOWN ISSUES IN NEW VERSION
+=====
+
+- Cancel chain will not work because we don't have parent task it. Do we need it though?
+We could just allow kill all by class name and that would be sufficient? (see runner.rb add_sw_params)
+
+
+
+
 Getting Started
 ===============
 
@@ -252,6 +261,17 @@ uploaded separately and treated as distinctly separate workers.
 
     merge_worker "./other_worker.rb", "OtherWorker"
 
+Merging Mailers
+---------------------
+
+You could easily merge mailers you're using in your application.
+
+    merge_mailer 'mailer_file' #if your mailer's templates are placed in default path
+    #or
+    merge_mailer 'mailer_file', {:path_to_templates=>"templates_path"}#if you're using mailer outside of rails with custom templates path
+
+if you already set auto_merge=true all your mailers already merged.
+
 Merging Gems
 ---------------------
 

data/lib/simple_worker/base.rb

@@ -12,7 +12,7 @@ module SimpleWorker
       @merged = {}
       @merged_workers = {}
       @merged_gems = {}
-      @merged_mailers = []
+      @merged_mailers = {}
       @merged_folders = {}
       @unmerged = {}
       @unmerged_gems = {}
@@ -21,7 +21,7 @@ module SimpleWorker
         @merged = {}
         @merged_workers = {}
         @merged_gems = {}
-        @merged_mailers = []
+        @merged_mailers = {}
         @merged_folders = {}
         @unmerged = {}
         @unmerged_gems = {}
@@ -30,15 +30,8 @@ module SimpleWorker
       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(":"))]
-#        puts 'caller_file=' + caller_file
-# don't need these class_variables anymore probably
         subclass.instance_variable_set(:@caller_file, caller_file)
 
         super
@@ -60,7 +53,7 @@ module SimpleWorker
       def unmerge_gem(gem_name)
         #gem_info = {:name=>gem_name}
         #@unmerged_gems[gem_name.to_s] = gem_info
-         gs = gem_name.to_s
+        gs = gem_name.to_s
         gem_info = {:name=>gs}
         @unmerged_gems[gs] = gem_info
         @merged_gems.delete(gs)
@@ -68,10 +61,10 @@ module SimpleWorker
 
       #merge action_mailer mailers
       def merge_mailer(mailer, params={})
-         f2 = SimpleWorker::MergeHelper.check_for_file mailer, caller[2]
+        f2 = SimpleWorker::MergeHelper.check_for_file mailer, caller[2]
         basename = File.basename(mailer, File.extname(mailer))
         path_to_templates = params[:path_to_templates] || File.join(Rails.root, "app/views/#{basename}")
-        @merged_mailers << {:name=>basename, :path_to_templates=>path_to_templates, :filename => mailer}.merge!(params)
+        @merged_mailers[basename] = {:name=>basename, :path_to_templates=>path_to_templates, :filename => mailer}.merge!(params)
       end
 
       def merge_folder(path)
@@ -99,23 +92,22 @@ module SimpleWorker
       # merges the specified file.
       #
       # Example: merge 'models/my_model'
-      def merge(*files)
+      def merge(f)
         ret = nil
-        files.each do |f|
-          f2 = SimpleWorker::MergeHelper.check_for_file(f, caller[2])
-          ret = {:name=>f, :path=>f2}
-          @merged[File.basename(f2)] = ret
-        end
+        f2 = SimpleWorker::MergeHelper.check_for_file(f, caller[2])
+        fbase = File.basename(f2)
+        ret = {:name=>fbase, :path=>f2}
+        @merged[fbase] = ret
         ret
       end
 
       # Opposite of merge, this will omit the files you specify from being merged in. Useful in Rails apps
       # where a lot of things are auto-merged by default like your models.
-      def unmerge(*files)
-        files.each do |f|
-          f2 = SimpleWorker::MergeHelper.check_for_file(f, caller[2])
-          @unmerged[File.basename(f2)] = {:name=>f, :path=>f2}
-        end
+      def unmerge(f)
+        f2 = SimpleWorker::MergeHelper.check_for_file(f, caller[2])
+        fbase = File.basename(f2)
+        @unmerged[fbase] = {:name=>fbase, :path=>f2}
+        @merged.delete(fbase)
       end
 
 
@@ -346,7 +338,7 @@ module SimpleWorker
         #puts 'merging caller file: ' + superclass.instance_variable_get(:@caller_file).inspect
         caller_to_add = superclass.instance_variable_get(:@caller_file)
         fb = File.basename(caller_to_add)
-        r = {:name=>fb, :path=>f2}
+        r = {:name=>fb, :path=>caller_to_add}
         super_merged[fb] = r
         merged.merge!(super_merged)
         #puts 'merged with superclass=' + merged.inspect
@@ -400,24 +392,24 @@ module SimpleWorker
 #        puts 'merged1=' + merged.inspect
 
         merged, rfile, subclass = SimpleWorker::Base.extract_superclasses_merges(self, merged)
-        #if SimpleWorker.config.auto_merge
-          puts "Auto merge Enabled"
-          #if SimpleWorker.config.models
-          #  SimpleWorker.config.models.each do |m|
-          #    merged[m] = m
-          #  end
-          #end
-          merged_mailers += SimpleWorker.config.mailers if SimpleWorker.config.mailers
-          #SimpleWorker.config.gems.each do |gem|
-          #  merged_gems[gem[:name]] = gem
-          #end
-        #end
+#if SimpleWorker.config.auto_merge
+        puts "Auto merge Enabled"
+#if SimpleWorker.config.models
+#  SimpleWorker.config.models.each do |m|
+#    merged[m] = m
+#  end
+#end
+        merged_mailers = merged_mailers.merge(SimpleWorker.config.mailers) if SimpleWorker.config.mailers
+#SimpleWorker.config.gems.each do |gem|
+#  merged_gems[gem[:name]] = gem
+#end
+#end
         unless merged_gems.size == 0
           merged_gems = gems_to_merge(merged_gems)
           #merged_gems.uniq!
         end
 #merged.uniq!
-        merged_mailers.uniq!
+#        merged_mailers.uniq!
         options_for_upload = {:merge=>merged, :unmerge=>unmerged, :merged_gems=>merged_gems, :merged_mailers=>merged_mailers, :merged_folders=>merged_folders}
         options_for_upload[:name] = options[:name] if options[:name]
         SimpleWorker.service.upload(rfile, subclass.name, options_for_upload)

data/lib/simple_worker/config.rb

@@ -60,7 +60,7 @@ module SimpleWorker
           c2.models = models
           models.each { |model| c2.merge(model) }
           mailers_path = File.join(Rails.root, 'app/mailers/*.rb')
-          c2.mailers = Dir.glob(mailers_path).collect { |m| {:filename=>m, :name => File.basename(m), :path_to_templates=>File.join(Rails.root, "app/views/#{File.basename(m, File.extname(m))}")} }
+          Dir.glob(mailers_path).collect { |m| c2.mailers[File.basename(m)] = {:filename=>m, :name => File.basename(m), :path_to_templates=>File.join(Rails.root, "app/views/#{File.basename(m, File.extname(m))}")} }
           c2.extra_requires += ['active_support/core_ext', 'action_mailer']
           #puts 'DB FILE=' + File.join(Rails.root, 'config', 'database.yml').to_s
           if defined?(ActiveRecord) && File.exist?(File.join(Rails.root, 'config', 'database.yml'))
@@ -142,6 +142,8 @@ module SimpleWorker
 
     def get_atts_to_send
       config_data = {}
+      config_data['access_key'] = access_key
+      config_data['secret_key'] = secret_key
       config_data['database'] = self.database if self.database
       config_data['global_attributes'] = self.global_attributes if self.global_attributes
       config_data['host'] = self.host if self.host
@@ -150,8 +152,17 @@ module SimpleWorker
 
     def merge(file)
       f2 = SimpleWorker::MergeHelper.check_for_file(file, caller[2])
-      ret = {:name=>file, :path=>f2}
-      @merged[File.basename(f2)] = ret
+      fbase = File.basename(f2)
+      ret = {:name=>fbase, :path=>f2}
+      @merged[fbase] = ret
+      ret
+    end
+
+    def unmerge(file)
+      f2 = SimpleWorker::MergeHelper.check_for_file(file, caller[2])
+      fbase = File.basename(f2)
+      @unmerged[fbase] = {:name=>fbase, :path=>f2}
+      @merged.delete(fbase)
     end
 
     # Merge a gem globally here

data/lib/simple_worker/server/overrides.rb

@@ -0,0 +1,204 @@
+
+# This is used when a bad worker is uploaded.
+class InvalidWorkerError < StandardError
+
+end
+
+
+module SimpleWorker
+
+  class << self
+    def running_class=(rc)
+      @@running_class = rc
+    end
+    def running_class
+      @@running_class
+    end
+  end
+
+  def self.disable_queueing()
+    @@queueing_enabled = false
+  end
+
+  def self.enable_queueing()
+    @@queueing_enabled = true
+  end
+
+  def self.queueing_enabled?
+    @@queueing_enabled
+  end
+
+
+  class Base
+
+    class << self
+
+      def merge(*files)
+        #files.each do |file|
+        #  file = file.to_s
+        #  unless file.end_with?(".rb")
+        #    file << ".rb"
+        #  end
+        #  #puts 'code_dir=' + code_dir.inspect
+        #  filename = File.join(code_dir, File.basename(file))
+        #  #puts "merge #{filename}"
+        #  #puts "FILENAME #{filename}"
+        #  require filename if File.exist?(filename) # for backwards compatability
+        #end
+
+      end
+
+
+      def merge_folder(path)
+        #puts "PATH=#{path}"
+        #puts "#{code_dir}/#{Digest::MD5.hexdigest(path)}/**/*.rb"
+        #Dir["#{code_dir}/#{Digest::MD5.hexdigest(path)}/**/*.rb"].each do |f|
+        #  puts "requiring #{f.inspect}"
+        #  require f if File.exist?(f)
+        #end
+      end
+
+      def unmerge(*files)
+        # ignore this here
+      end
+
+      def merge_mailer(mailer, params=nil)
+        #merge(mailer)
+      end
+
+      def merge_gem(gem, version=nil)
+        #gem_info = {:name=>gem}
+        #if version.is_a?(Hash)
+        #  gem_info.merge!(version)
+        #else
+        #  gem_info[:version] = version
+        #end
+        #gem_name =(gem.match(/^[a-zA-Z0-9\-_]+/)[0])
+        #$LOAD_PATH << File.join(code_dir, "/gems/#{gem_name}") #backwards compatibility, should be removed later
+        #$LOAD_PATH << File.join(code_dir, "/gems/#{gem_name}/lib")
+        #                                                       # what's the diff here? This one seems more common: $:.unshift File.join(File.dirname(__FILE__), "/gems/#{gem_name}")
+        #                                                       #puts 'gem_info = ' + gem_info.inspect
+        #require gem_info[:require] || gem_name
+      end
+
+      def merge_worker(file, class_name)
+
+      end
+
+    end
+
+    def is_remote?
+      true
+    end
+
+    #:todo remove this method later, when new simple_worker gem will be released
+    def is_local?
+      !is_remote?
+    end
+
+    def log(str)
+      puts str.to_s
+    end
+
+    def set_progress(hash)
+      SimpleWorker.service.set_progress(@job_data["task_id"], hash)
+    end
+
+    def something
+      puts 'which class? ' + self.class.name
+    end
+
+    def user_dir
+#      puts 'user_dir=' + @context.user_dir.to_s
+      @context.user_dir
+    end
+
+    def sw_set_data(data)
+      if data["attr_encoded"]
+        # new way, attributes are base 64 encoded
+        data = JSON.parse(Base64.decode64(data["attr_encoded"]))
+      end
+
+      data.each_pair do |k, v|
+        next unless k[0] == "@"
+#        puts "setting instance_variable #{k}=#{v}"
+        self.instance_variable_set(k, v)
+      end
+
+    end
+
+    def upload_if_needed(options={})
+      puts "No uploading in worker service."
+    end
+
+    alias_method :orig_queue, :queue
+    alias_method :orig_schedule, :schedule
+    alias_method :orig_status, :status
+
+    def queue(options={})
+      if SimpleWorker.queueing_enabled? && (!same_clazz? || options[:recursive])
+        orig_queue(options)
+#        data = sw_get_data()
+#        queue_other(self.class.name, data)
+      else
+        log (SimpleWorker.queueing_enabled? ? "WARNING: Recursion detected in queueing, pass in :recursive=>true to bypass this." : "Queuing disabled while loading.")
+      end
+    end
+
+    def schedule(schedule)
+      if SimpleWorker.queueing_enabled? && (!same_clazz? || schedule[:recursive])
+        orig_schedule(schedule)
+#        data = sw_get_data()
+#        schedule_other(self.class.name, data, schedule)
+      else
+        log (SimpleWorker.queueing_enabled? ? "WARNING: Recursion detected in scheduling." : "Scheduling disabled while loading.")
+      end
+
+    end
+
+    def status
+      if SimpleWorker.queueing_enabled?
+        orig_status
+      else
+        log "Status disabled while loading."
+      end
+    end
+
+    def same_clazz?
+      SimpleWorker.running_class == self.class
+    end
+
+  end
+
+
+  class Service < SimpleWorker::Api::Client
+    def upload(filename, class_name, options={})
+      #puts "Skipping upload, We don't upload from run.rb!"
+      # don't upload, should already be here.
+    end
+
+    def add_sw_params(hash_to_send)
+      hash_to_send["sw_access_key"] = self.access_key
+      hash_to_send["sw_secret_key"] = self.secret_key
+      hash_to_send["api_version"] = SimpleWorker.api_version
+      #if defined?(SimpleWorker::SingleRunner)
+      #  #puts "IN SINGLE RUNNER"
+      #  runners = ObjectSpace.each_object(SimpleWorker::SingleRunner)
+      #  if runners
+      #    single_runner = runners.first
+      #    #puts "PUTTING PARENT TASK ID #{single_runner.instance_variable_get(:@parent_task_id)|| single_runner.instance_variable_get(:@task_id)}"
+      #    hash_to_send["sw_parent_task_id"] =single_runner.instance_variable_get(:@parent_task_id)|| single_runner.instance_variable_get(:@task_id)
+      #  end
+      #end
+    end
+  end
+
+
+  module UsedInWorker
+    def log(str)
+      puts str.to_s
+    end
+  end
+
+
+end

data/lib/simple_worker/server/runner.rb

@@ -0,0 +1,96 @@
+# This is the file that gets executed on the server.
+
+
+def init_database_connection(sw_config)
+  if sw_config
+    db_config = sw_config['database']
+    if db_config
+      #@logger.info "Connecting to database using ActiveRecord..."
+      require 'active_record'
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+  end
+end
+
+def get_class_to_run(class_name)
+  runner_class = Kernel.const_get(class_name)
+  return runner_class
+end
+
+def init_runner(runner_class, job_data)
+  # ensure initialize takes no arguments
+  init_arity = runner_class.instance_method(:initialize).arity
+  if init_arity == 0 || init_arity == -1
+    # good. -1 can be if it's not defined at all
+  else
+    raise InvalidWorkerError, "Worker initialize method must accept zero arguments."
+  end
+  runner = runner_class.new
+  runner.instance_variable_set(:@job_data, job_data)
+  runner.instance_variable_set(:@sw_config, job_data['sw_config'])
+  runner.sw_set_data(job_data)
+  runner
+end
+
+def init_worker_service_for_runner(job_data)
+  SimpleWorker.configure do |config|
+    sw_config = job_data['sw_config']
+    config.access_key = sw_config['access_key']
+    config.secret_key = sw_config['secret_key']
+    #puts 'Setting host to ' + host.inspect
+    config.host = sw_config['host'] if sw_config['host']
+    db_config = sw_config['database']
+    if db_config
+      config.database = db_config
+    end
+    config.global_attributes = sw_config['global_attributes'] if sw_config['global_attributes']
+  end
+end
+
+# Find environment (-e)
+dirname = ""
+i = 0
+job_data_file = run_data_file = nil
+puts "args for single file=" + ARGV.inspect
+ARGV.each do |arg|
+  if arg == "-d"
+    # the user's writable directory
+    dirname = ARGV[i+1]
+  end
+  if arg == "-j"
+    # path to job data
+    job_data_file = ARGV[i+1]
+  end
+  if arg == "-p"
+    # path to run data
+    run_data_file = ARGV[i+1]
+  end
+  i+=1
+end
+
+# Change to user directory
+puts 'dirname=' + dirname.inspect
+Dir.chdir(dirname)
+
+run_data = JSON.load(File.open(run_data_file))
+# Load in job data
+job_data = JSON.load(File.open(job_data_file))
+job_data.merge!(run_data)
+puts 'job_data=' + job_data.inspect
+
+sw_config = job_data['sw_config']
+begin
+  init_database_connection(sw_config)
+  SimpleWorker.disable_queueing()
+  runner_class = get_class_to_run(job_data['class_name'])
+  SimpleWorker.running_class = runner_class
+  runner = init_runner(runner_class, job_data)
+  init_worker_service_for_runner(job_data)
+  SimpleWorker.enable_queueing()
+
+# Let's run it!
+  runner_return_data = runner.run
+rescue Exception => ex
+  $stderr.puts "_error_from_sw_"
+  raise ex
+end

data/lib/simple_worker/service.rb

@@ -60,6 +60,7 @@ module SimpleWorker
         options = {
             "class_name"=>class_name,
             "name"=>name,
+            "standalone"=>true,
             "file_name"=> "runner.rb" # File.basename(filename)
         }
         #puts 'options for upload=' + options.inspect
@@ -115,15 +116,15 @@ module SimpleWorker
       end
       puts 'merged_gems_after=' + merged_gems.inspect
 
+      merged_mailers ||= {}
+      merged_mailers = merged_mailers.merge(SimpleWorker.config.mailers) if SimpleWorker.config.mailers
+
       #tmp_file = File.join(Dir.tmpdir(), File.basename(filename))
       tmp_file = File.join(Dir.tmpdir(), 'runner.rb')
       File.open(tmp_file, "w") do |f|
         # add some rails stuff if using Rails
 
-        merge.each_pair do |k, v|
-          SimpleWorker.logger.debug "merging #{k} into #{filename}"
-          f.write("require_relative '#{k}'\n") # add(File.basename(m), m)
-        end
+        f.write("require 'simple_worker'\n")
 
         if defined?(Rails)
           f.write "module Rails
@@ -136,51 +137,62 @@ module SimpleWorker
 end
 "
         end
-        if SimpleWorker.config.extra_requires
-          SimpleWorker.config.extra_requires.each do |r|
-            f.write "require '#{r}'\n"
-          end
-        end
+
         if merged_mailers && !merged_mailers.empty?
           # todo: isn't 'action_mailer already required in railtie?
           f.write "require 'action_mailer'\n"
           f.write "ActionMailer::Base.prepend_view_path('templates')\n"
         end
         #if SimpleWorker.config.auto_merge
-        if SimpleWorker.config.merged_gems
-          SimpleWorker.config.merged_gems.each_pair do |k, gem|
-            puts "Bundling gem #{gem[:name]}..."
-            if gem[:merge]
-              f.write "$LOAD_PATH << File.join(File.dirname(__FILE__), '/gems/#{gem[:name]}/lib')\n"
-            end
+        merged_gems.each_pair do |k, gem|
+          puts "Bundling gem #{gem[:name]}..."
+          if gem[:merge]
+            f.write "$LOAD_PATH << File.join(File.dirname(__FILE__), '/gems/#{gem[:name]}/lib')\n"
+          end
 #              unless gem[:no_require]
-            puts 'writing requires: ' + gem[:require].inspect
-            if gem[:require].nil?
-              gem[:require] = []
-            elsif gem[:require].is_a?(String)
-              gem[:require] = [gem[:require]]
-            end
-            puts gem[:require].inspect
-            gem[:require].each do |r|
-              puts 'adding require to file ' + r.to_s
-              f.write "require '#{r}'\n"
-            end
-#              end
+          puts 'writing requires: ' + gem[:require].inspect
+          if gem[:require].nil?
+            gem[:require] = []
+          elsif gem[:require].is_a?(String)
+            gem[:require] = [gem[:require]]
+          end
+          puts gem[:require].inspect
+          gem[:require].each do |r|
+            puts 'adding require to file ' + r.to_s
+            f.write "require '#{r}'\n"
           end
+#              end
         end
-        if SimpleWorker.config.merged
-          SimpleWorker.config.merged.each_pair do |k, v|
-            f.write "require_relative '#{File.basename(v[:path])}'\n"
+
+        if SimpleWorker.config.extra_requires
+          SimpleWorker.config.extra_requires.each do |r|
+            f.write "require '#{r}'\n"
           end
         end
-        if SimpleWorker.config.mailers
-          SimpleWorker.config.mailers.each do |mailer|
-            f.write "require_relative '#{mailer[:name]}'\n"
+
+        File.open(File.join(File.dirname(__FILE__), 'server', 'overrides.rb'), 'r') do |fr|
+          while line = fr.gets
+            f.write line
           end
         end
+
+        merged.each_pair do |k, v|
+          f.write "require_relative '#{File.basename(v[:path])}'\n"
+        end
+        merged_mailers.each_pair do |k, mailer|
+          f.write "require_relative '#{mailer[:name]}'\n"
+        end
         #end
         #f.write File.open(filename, 'r') { |mo| mo.read }
         f.write("require_relative '#{File.basename(filename)}'")
+
+        File.open(File.join(File.dirname(__FILE__), "server", 'runner.rb'), 'r') do |fr|
+          while line = fr.gets
+            f.write line
+          end
+        end
+
+
       end
       #puts 'funner.rb=' + tmp_file
       merge['runner.rb'] = {:path=>tmp_file}
@@ -242,7 +254,7 @@ end
         end
         if merged_mailers && merged_mailers.size > 0
           # puts " MERGED MAILERS" + merged_mailers.inspect
-          merged_mailers.each do |mailer|
+          merged_mailers.each_pair do |k, mailer|
             SimpleWorker.logger.debug "Collecting mailer #{mailer[:name]}"
             f.add(File.basename(mailer[:filename]), mailer[:filename])
             path = mailer[:path_to_templates]
@@ -281,16 +293,21 @@ end
       if !data.is_a?(Array)
         data = [data]
       end
+      data.each do |d|
+        d['class_name'] = class_name
+        d['access_key'] = class_name
+      end
       name = options[:name] || class_name
       hash_to_send = {}
       hash_to_send["payload"] = data
       hash_to_send["class_name"] = class_name
       hash_to_send["name"] = name
+      #hash_to_send["standalone"] = true # new school
       hash_to_send["priority"] = options[:priority] if options[:priority]
       hash_to_send["options"] = options
       add_sw_params(hash_to_send)
       if defined?(RAILS_ENV)
-        # todo: move this to global_attributes in railtie
+        # todo: REMOVE THIS
         hash_to_send["rails_env"] = RAILS_ENV
       end
       return queue_raw(class_name, hash_to_send)
@@ -358,6 +375,12 @@ end
       ret
     end
 
+    # data is a hash, should include 'percent' and 'message'
+    def set_progress(task_id, data)
+      data={"data"=>data, "task_id"=>task_id}
+      post("task/setstatus", data)
+    end
+
     def log(task_id)
       data = {"task_id"=>task_id}
       ret = get("task/log", data, {:parse=>false})

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: simple_worker
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.7.4
+  prerelease: 6
+  version: 1.0.0.beta
 platform: ruby
 authors: 
 - Travis Reeder
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-03 00:00:00 Z
+date: 2011-08-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zip
@@ -49,7 +49,8 @@ files:
 - lib/simple_worker/api.rb
 - lib/simple_worker/base.rb
 - lib/simple_worker/config.rb
-- lib/simple_worker/runner.rb
+- lib/simple_worker/server/overrides.rb
+- lib/simple_worker/server/runner.rb
 - lib/simple_worker/service.rb
 - lib/simple_worker/used_in_worker.rb
 - lib/simple_worker/utils.rb
@@ -72,9 +73,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 

data/lib/simple_worker/runner.rb

@@ -1 +0,0 @@
-# This is the file that gets executed on the server.