iron_worker 2.4.3 → 3.0.0

data/README.markdown

@@ -1,73 +0,0 @@
-Getting Started
-===============
-
-[Sign up for a IronWorker account][1], it's free to try!
-
-[1]: http://www.iron.io/
-
-**WARNING**: THIS GEM IS DEPRECATED. Use the generation IronWorker gem, `iron_worker_ng`, 
-at: https://github.com/iron-io/iron_worker_ruby_ng. It also includes our new IronWorker command line 
-interface (CLI) which is... awesome. ;) You can [read more about that here](http://blog.iron.io/2012/05/new-ironworker-command-line-interface.html). 
-
-Install IronWorker Gem
-------------------------
-
-    gem install iron_worker
-
-Configure IronWorker
-----------------------
-
-You really just need your token, which you can get [here][2]
-[2]: http://hud.iron.io/tokens
-
-    IronWorker.configure do |config|
-        config.token = TOKEN
-        config.project_id = MY_PROJECT_ID
-    end
-
-Write a Worker
---------------
-
-Here's an example worker that sends an email:
-
-    require 'iron_worker'
-
-    class HelloWorker < IronWorker::Base
-
-        attr_accessor :name
-
-        # This is the method that will be run
-        def run
-            puts "Hello #{name}!"
-        end
-    end
-
-Test It Locally
----------------
-
-Let's say someone does something in your app and you want to send an email about it.
-
-    worker = HelloWorker.new
-    worker.name = "Travis"
-    worker.run_local
-
-Once you've got it working locally, the next step is to run it on the IronWorker cloud.
-
-Queue up your Worker on the IronWorker Cloud
-----------------------------------------------
-
-Let's say someone does something in your app and you want to send an email about it.
-
-    worker = HelloWorker.new
-    worker.name = "Travis"
-    worker.queue
-
-This will send it off to the IronWorker cloud.
-
-Full Documentation
------------------
-
-Now that you've got your first worker running, be sure to [check out the full documentation](https://github.com/iron-io/iron_worker_ruby/wiki).
-IronWorker can do so much more! 
-
-And check out the [Iron.io Dev Center](http://dev.iron.io) for full IronWorker API documentation and and support for other languages.

data/lib/generators/iron_worker/iron_worker_generator.rb

@@ -1,13 +0,0 @@
-class IronWorkerGenerator < Rails::Generators::NamedBase
-  source_root File.expand_path("../templates", __FILE__)
- 
-  desc "Creates a new skeleton worker - NAME is camelized"
-  def create_worker_file
-    # file_name needs to be classified
-    @camel = file_name.camelize
-    if not File.directory? "#{Rails.root}/app/workers"
-      Dir.mkdir "#{Rails.root}/app/workers"
-    end
-    template "template_worker.erb", "app/workers/#{file_name}.rb" 
-  end
-end

data/lib/generators/iron_worker/templates/template_worker.erb

@@ -1,7 +0,0 @@
-class <%= @camel %> < IronWorker::Base
-
-  def run
-    log "Your code goes in this bit"
-  end
-
-end

data/lib/iron_worker/api.rb

@@ -1,244 +0,0 @@
-require 'rest'
-
-module IronWorker
-
-  class RequestError < StandardError
-    def initialize(msg, options={})
-      super(msg)
-      @options = options
-    end
-
-    def status
-      @options[:status]
-    end
-  end
-
-  module Api
-
-    module Signatures
-
-
-      def self.generate_timestamp(gmtime)
-        return gmtime.strftime("%Y-%m-%dT%H:%M:%SZ")
-      end
-
-
-      def self.generate_signature(operation, timestamp, secret_key)
-        my_sha_hmac = Digest::HMAC.digest(operation + timestamp, secret_key, Digest::SHA1)
-        my_b64_hmac_digest = Base64.encode64(my_sha_hmac).strip
-        return my_b64_hmac_digest
-      end
-
-
-      def self.hash_to_s(hash)
-        str = ""
-        hash.sort.each { |a| str+= "#{a[0]}#{a[1]}" }
-        #removing all characters that could differ after parsing with rails
-        return str.delete "\"\/:{}[]\' T"
-      end
-    end
-
-    # Subclass must define:
-    #  host: endpoint url for service
-    class Client
-
-      attr_accessor :scheme, :host, :port, :token, :version, :config
-
-      def initialize(host, token, options={})
-        @config = options[:config]
-        @scheme = options[:scheme] || @config.scheme || "https"
-        @host = options[:host] || @config.host || host
-        @port = options[:port] || @config.port || 443
-        @token = options[:token] || @config.token || token
-        @version = options[:version]
-        #@logger = options[:logger]
-
-        reset_base_url
-
-        @uber_client = Rest::Client.new
-
-      end
-
-      def reset_base_url
-        @base_url = "#{@scheme}://#{@host}:#{@port}/#{@version}"
-      end
-
-      def base_url
-        @base_url
-      end
-
-      def url(command_path)
-        # @logger.debug "url: " + url.to_s
-        "/#{command_path}"
-      end
-
-      def url_full(command_path)
-        url = "#{base_url}/#{command_path}"
-        # @logger.debug "url: " + url.to_s
-        url
-      end
-
-
-      def common_req_hash
-        {
-            :headers=>{"Content-Type" => 'application/json',
-                       "Authorization"=>"OAuth #{@token}",
-                       "User-Agent"=>"IronWorker Ruby Client"}
-        }
-      end
-
-      def process_ex(ex)
-        logger.error "EX #{ex.class.name}: #{ex.message}"
-        body = ex.http_body
-        logger.debug 'EX http_code: ' + ex.http_code.to_s
-        logger.debug 'EX BODY=' + body.to_s
-        decoded_ex = JSON.parse(body)
-        exception = Exception.new(ex.message + ": " + decoded_ex["msg"])
-        exception.set_backtrace(decoded_ex["backtrace"].split(",")) if decoded_ex["backtrace"]
-        raise exception
-      end
-
-
-      def check_response(response, options={})
-        # response.code    # http status code
-        #response.time    # time in seconds the request took
-        #response.headers # the http headers
-        #response.headers_hash # http headers put into a hash
-        #response.body    # the response body
-        status = response.code
-        body = response.body
-        # todo: check content-type == application/json before parsing
-        logger.debug "response code=" + status.to_s
-        logger.debug "response body=" + body.inspect
-        res = nil
-        unless options[:parse] == false
-          res = JSON.parse(body)
-        end
-        if status < 400
-
-        else
-          raise IronWorker::RequestError.new((res ? "#{status}: #{res["msg"]}" : "#{status} Error! parse=false so no msg"), :status=>status)
-        end
-        res || body
-      end
-
-      def get(method, params={}, options={})
-        full_url = url_full(method)
-        #all_params = add_params(method, params)
-        #url_plus_params = append_params(full_url, all_params)
-        logger.debug 'get url=' + full_url
-        req_hash = common_req_hash
-        req_hash[:params] = params
-        response = @uber_client.get(full_url, req_hash) # could let typhoeus add params, using :params=>x
-        #response = @http_sess.request(:get, url_plus_params,
-        #                              {},
-        #                              {})
-        check_response(response, options)
-        body = response.body
-        parse_response(body, options)
-
-      end
-
-      def post_file(method, file, params={}, options={})
-        begin
-          data = add_params(method, params).to_json
-          url = url_full(method)
-          logger.debug "post_file url = " + url
-          logger.debug "data = " + data
-          logger.debug "params = " + params.inspect
-          logger.debug "options = " + options.inspect
-          # todo: replace with uber_client
-          parse_response(RestClient.post(append_params(url, add_params(method, params)), {:data => data, :file => file}, :content_type => 'application/json'), options)
-        rescue RestClient::Exception => ex
-          process_ex(ex)
-        end
-      end
-
-      def post(method, params={}, options={})
-        logger.debug "params = " + params.inspect
-        logger.debug "options = " + options.inspect
-        logger.debug "params.payload = " + params[:payload].inspect
-        logger.debug "token = "+ token.inspect
-        begin
-          url = url_full(method)
-          logger.debug 'post url=' + url
-          json = add_params(method, params).to_json
-          logger.debug 'body=' + json
-          req_hash = common_req_hash
-          req_hash[:body] = json
-          response = @uber_client.post(url, req_hash)
-          #response = @http_sess.post(url, json, {"Content-Type" => 'application/json'})
-          check_response(response)
-          logger.debug 'response: ' + response.inspect
-          body = response.body
-          parse_response(body, options)
-        rescue IronWorker::RequestError => ex
-          # let it throw, came from check_response
-          raise ex
-        rescue RestClient::Exception => ex
-          logger.warn("Exception in post! #{ex.message}")
-          logger.warn(ex.backtrace.join("\n"))
-          process_ex(ex)
-        end
-      end
-
-
-      def put(method, body, options={})
-        begin
-          # todo: replace with uber_client
-          parse_response RestClient.put(url_full(method), add_params(method, body).to_json, headers), options
-        rescue RestClient::Exception => ex
-          process_ex(ex)
-        end
-      end
-
-      def delete(method, params={}, options={})
-        begin
-          # todo: replace with uber_client
-          parse_response RestClient.delete(append_params(url_full(method), add_params(method, params))), options
-        rescue RestClient::Exception => ex
-          process_ex(ex)
-        end
-      end
-
-      def add_params(command_path, hash)
-        extra_params = {'oauth' => token}
-        hash.merge!(extra_params)
-      end
-
-      def append_params(host, params)
-        host += "?"
-        i = 0
-        params.each_pair do |k, v|
-          #puts "k=#{k} v=#{v}"
-          host += "&" if i > 0
-          host += k + "=" + (v.is_a?(String) ? CGI.escape(v) : v.to_s)
-          i +=1
-        end
-        return host
-      end
-
-      def headers
-        user_agent = "IronWorker Ruby Client"
-        headers = {'User-Agent' => user_agent}
-      end
-
-      def parse_response(response, options={})
-        #puts 'PARSE RESPONSE: ' + response.to_s
-        unless options[:parse] == false
-          begin
-            return JSON.parse(response.to_s)
-          rescue => ex
-            puts 'parse_response: response that caused error = ' + response.to_s
-            raise ex
-          end
-        else
-          response
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/iron_worker/base.rb

@@ -1,449 +0,0 @@
-require 'digest/md5'
-require 'base64'
-
-module IronWorker
-
-  class Base
-
-    attr_accessor :task_set_id, :task_id, :schedule_id
-    attr_reader :response
-
-    class << self
-      attr_accessor :subclass, :caller_file
-      @merged = {}
-      @merged_workers = {}
-      @merged_gems = {}
-      @merged_mailers = {}
-      @merged_folders = {}
-      @unmerged = {}
-      @unmerged_gems = {}
-
-      def reset!
-        @merged = {}
-        @merged_workers = {}
-        @merged_gems = {}
-        @merged_mailers = {}
-        @merged_folders = {}
-        @unmerged = {}
-        @unmerged_gems = {}
-      end
-
-      def inherited(subclass)
-        subclass.reset!
-
-        caller_file = caller[0][0...(caller[0].index(":in"))]
-        caller_file = caller_file[0...(caller_file.rindex(":"))]
-        subclass.instance_variable_set(:@caller_file, caller_file)
-
-        super
-      end
-
-      # merges the specified gem.
-      def merge_gem(gem_name, options={})
-        gem_info = IronWorker::MergeHelper.create_gem_info(gem_name, options)
-        @merged_gems[gem_name.to_s] = gem_info
-        reqs = gem_info[:require].is_a?(Array) ? gem_info[:require] : [gem_info[:require]]
-        reqs.each do |r|
-          r2 = "#{gem_info[:path]}/lib/#{r}"
-          begin
-            IronWorker.logger.debug 'requiring ' + r2
-            require r2
-          rescue LoadError=>ex
-            IronWorker.logger.error "Error requiring gem #{r}: #{ex.message}"
-            raise "Gem #{gem_name} was found, but we could not load the file '#{r2}'. You may need to use :require=>x.........."
-          end
-        end
-      end
-
-
-      def unmerge_gem(gem_name)
-        #gem_info = {:name=>gem_name}
-        #@unmerged_gems[gem_name.to_s] = gem_info
-        gs = gem_name.to_s
-        gem_info = {:name=>gs}
-        @unmerged_gems[gs] = gem_info
-        @merged_gems.delete(gs)
-      end
-
-      #merge action_mailer mailers
-      def merge_mailer(mailer, params={})
-        f2 = IronWorker::MergeHelper.check_for_file(mailer, @caller_file)
-        basename = File.basename(mailer, f2[:extname])
-        path_to_templates = params[:path_to_templates] || File.join(Rails.root, "app/views/#{basename}")
-        path_to_layouts = params[:path_to_layouts] || File.join(Rails.root, "app/views/layouts")
-        @merged_mailers[basename] = {:name => basename, :path_to_templates => path_to_templates, :path_to_layouts => path_to_layouts, :filename => f2[:path]}.merge!(params)
-      end
-
-
-      def merge_folder(path)
-        files = []
-        #puts "caller_file=" + caller_file
-        if path[0, 1] == '/'
-          abs_dir = path
-        else # relative
-          abs_dir = File.join(File.dirname(caller_file), path)
-        end
-        #puts 'abs_dir=' + abs_dir
-        raise "Folder not found for merge_folder #{path}!" unless File.directory?(abs_dir)
-        rbfiles = File.join(abs_dir, "*.rb")
-        Dir[rbfiles].each do |f|
-          #f2 = check_for_file(f)
-          #puts "f2=#{f2}"
-          merge(f)
-          #files << f
-          #@merged[f]
-        end
-        #@merged_folders[path] = files unless files.empty?
-        #IronWorker.logger.info "Merged folders! #{@merged_folders.inspect}"
-      end
-
-      # merges the specified file.
-      #
-      # Example: merge 'models/my_model'
-      def merge(f)
-        f2 = IronWorker::MergeHelper.check_for_file(f, @caller_file)
-        fbase = f2[:basename]
-        ret = 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(f)
-        f2 = IronWorker::MergeHelper.check_for_file(f, @caller_file)
-        fbase = f2[:basename]
-        @unmerged[fbase] = f2
-        @merged.delete(fbase)
-      end
-
-
-      # Use this to merge in other workers. These are treated differently the normal merged files because
-      # they will be uploaded separately and treated as distinctly separate workers.
-      #
-      # @param file [String] This is the path to the file, just like merge.
-      # @param class_name [String|Class] 'MyWorker' or just MyWorker.
-      # @return [Hash]
-      def merge_worker(file, class_name)
-        ret = merge(file)
-        ret[:class_name] = case class_name
-                             when String
-                               class_name.strip
-                             when Class
-                               class_name.name
-                             else
-                               IronWorker.service.logger.warn "merge_worker: only String or Class is expected as class_name"
-                               class_name # probably user does know what is he doing
-                           end
-        @merged_workers[file] = ret
-        ret
-      end
-    end
-
-
-    def log(str)
-      puts str.to_s
-    end
-
-    def user_dir
-      "./"
-    end
-
-    def set_progress(hash)
-      puts 'set_progress: ' + hash.inspect
-    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
-
-    # 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_auto_attributes
-      init_database
-      init_mailer
-      begin
-        run
-      rescue => ex
-        if self.respond_to?(:rescue_all)
-          rescue_all(ex)
-        else
-          raise ex
-        end
-      end
-    end
-
-    def init_mailer
-      if IronWorker.config.mailer
-        require 'action_mailer'
-        ActionMailer::Base.raise_delivery_errors = true
-        ActionMailer::Base.smtp_settings = (IronWorker.config.mailer)
-      end
-    end
-
-    def init_database
-      if IronWorker.config.database
-        require 'active_record'
-        if !ActiveRecord::Base.connected?
-          ActiveRecord::Base.establish_connection(IronWorker.config.database)
-        end
-      end
-    end
-
-    def set_auto_attributes
-      set_global_attributes
-    end
-
-    def set_global_attributes
-      return unless IronWorker.config
-      ga = IronWorker.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
-    end
-
-    def enqueue(options={})
-      queue(options)
-    end
-
-    # Call this to queue up your job to IronWorker cloud.
-    # options:
-    #   :priority => 0, 1 or 2. Default is 0.
-    #   :recursive => true/false. Default is false. If you queue up a worker that is the same class as the currently
-    #                 running worker, it will be rejected unless you set this explicitly so we know you meant to do it.
-    def queue(options={})
-#            puts 'in queue'
-
-      IronWorker.config.force_upload = IronWorker.config.force_upload && is_local?
-      set_auto_attributes
-      upload_if_needed(options)
-      response = IronWorker.service.queue(self.class.name, sw_get_data, options)
-      IronWorker.service.logger.debug 'queue response=' + response.inspect
-      @response = response
-      @task_id = response["tasks"][0]["id"]
-      response
-    end
-
-    # Receive the status of your worker.
-    def status
-      check_service
-      if task_id
-        task_status
-      elsif schedule_id
-        schedule_status
-      else
-        raise "Queue or schedule before check status."
-      end
-    end
-
-    def task_status
-      IronWorker.service.status(task_id)
-    end
-
-    def is_local?
-      IronWorker.is_local?
-    end
-
-    def is_remote?
-      IronWorker.is_remote?
-    end
-
-    # will return after job has completed or errored out.
-    # Returns status.
-    # todo: add a :timeout option
-    def wait_until_complete
-      check_service
-      raise "No ID for worker!" if self.task_id.nil? && self.schedule_id.nil?
-      IronWorker.service.wait_until_complete(self.task_id || self.schedule_id, :schedule=>is_schedule?)
-    end
-
-    def is_schedule?
-      !self.schedule_id.nil?
-    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.
-    #     - name:          Provide a name for the schedule, defaults to class name. Use this if you want more than one schedule per worker class.
-    #
-    def schedule(schedule)
-      set_global_attributes
-      upload_if_needed(schedule)
-
-      response = IronWorker.service.schedule(self.class.name, sw_get_data, schedule)
-      IronWorker.service.logger.debug 'schedule response=' + response.inspect
-      @schedule_id = response["schedules"][0]["id"]
-      response
-    end
-
-    def schedule_status
-      IronWorker.service.schedule_status(schedule_id)
-    end
-
-    # Retrieves the log for this worker from the IronWorker service.
-    def get_log(options={})
-      IronWorker.service.log(task_id, options)
-    end
-
-    # Callbacks for developer
-    def before_upload
-
-    end
-
-    def after_upload
-
-    end
-
-    def before_run
-
-    end
-
-    def after_run
-
-    end
-
-    private
-
-    def gems_to_merge(merged_gems)
-      list_of_gems = {}
-      if merged_gems && merged_gems.size > 0
-        installed_gems = IronWorker.config.get_server_gems
-        merged_gems.each_pair do |k, gem|
-          gem.merge!({:merge=>(!installed_gems.find { |g| g["name"]==gem[:name] && g["version"]==gem[:version] })})
-          list_of_gems[gem[:name]] = gem # don't' need this if (list_of_gems.select { |k,g| g[:name]==gem[:name] }).empty?
-        end
-        IronWorker.logger.debug "#{list_of_gems.inspect}"
-      end
-      list_of_gems
-    end
-
-    def check_service
-      raise "IronWorker configuration not set." unless IronWorker.service
-    end
-
-    def self.extract_superclasses_merges(worker, merged)
-      subclass = worker.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 IronWorker::Base
-      while (superclass = superclass.superclass)
-        #puts 'superclass=' + superclass.name
-        break if superclass.name == IronWorker::Base.name
-        super_merged = superclass.instance_variable_get(:@merged)
-        #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=>caller_to_add}
-        super_merged[fb] = r
-        merged.merge!(super_merged)
-        #puts 'merged with superclass=' + merged.inspect
-      end
-      return merged, rfile, subclass
-    end
-
-    def self.extract_merged_workers(worker)
-      merged_workers = worker.class.instance_variable_get(:@merged_workers)
-      IronWorker.logger.debug "Looking for merged_workers in #{worker.class.name}: #{merged_workers.inspect}"
-      ret = {}
-      if merged_workers && merged_workers.size > 0
-        merged_workers.each_pair do |k, mw|
-          IronWorker.logger.debug "merged worker found in #{worker.class.name}: #{mw.inspect}"
-          ret[mw[:name]] = mw
-        end
-      end
-      ret
-    end
-
-    def upload_if_needed(options={})
-      return if is_remote?
-      check_service
-      IronWorker.service.check_config
-
-      before_upload
-
-      merged = self.class.instance_variable_get(:@merged)
-
-      # do merged_workers first because we need to get their subclasses and what not too
-      merged_workers = self.class.instance_variable_get(:@merged_workers)
-      if merged_workers && merged_workers.size > 0
-        IronWorker.logger.debug 'now uploading merged workers ' + merged_workers.inspect
-        merged_workers.each_pair do |mw, v|
-          IronWorker.logger.debug 'Instantiating and uploading ' + v.inspect
-          mw_instantiated = Kernel.const_get(v[:class_name]).new
-          mw_instantiated.upload
-
-          merged, rfile, subclass = IronWorker::Base.extract_superclasses_merges(mw_instantiated, merged)
-          merged.merge!(IronWorker::Base.extract_merged_workers(mw_instantiated))
-
-        end
-      end
-
-      if !uploaded?
-        unmerged = self.class.instance_variable_get(:@unmerged)
-        merged_gems = self.class.instance_variable_get(:@merged_gems)
-        unmerged_gems = self.class.instance_variable_get(:@unmerged_gems)
-        merged_mailers = self.class.instance_variable_get(:@merged_mailers)
-        merged_folders = self.class.instance_variable_get(:@merged_folders)
-        merged, rfile, subclass = IronWorker::Base.extract_superclasses_merges(self, merged)
-        merged_mailers = merged_mailers.merge(IronWorker.config.mailers) if IronWorker.config.mailers
-        unless merged_gems.size == 0
-          merged_gems = gems_to_merge(merged_gems)
-        end
-
-        options_for_upload = {:merge=>merged, :unmerge=>unmerged, :merged_gems=>merged_gems, :unmerged_gems=>unmerged_gems, :merged_mailers=>merged_mailers, :merged_folders=>merged_folders}
-        options_for_upload.merge!(options)
-        IronWorker.service.upload(rfile, subclass.name, options_for_upload)
-        self.class.instance_variable_set(:@uploaded, true)
-      else
-        IronWorker.logger.debug 'Already uploaded for ' + self.class.name
-      end
-
-      after_upload
-    end
-
-    def sw_get_data
-      data = {}
-
-      payload = {}
-      # todo: should put these down a layer, eg: payload[:attributes]
-      self.instance_variables.each do |iv|
-        payload[iv] = instance_variable_get(iv)
-      end
-      data['class_name'] = self.class.name
-      data[:attr_encoded] = Base64.encode64(payload.to_json)
-      data[:file_name] = File.basename(self.class.instance_variable_get(:@caller_file))
-      if defined?(Rails)
-        data[:rails] = {}
-        data[:rails]['env'] = Rails.env
-        data[:rails]['version'] = Rails.version
-      end
-      config_data = IronWorker.config.get_atts_to_send
-      data[:sw_config] = config_data
-      return data
-    end
-
-
-  end
-end