iron_worker 2.1.0

data/README.markdown

@@ -0,0 +1,72 @@
+Getting Started
+===============
+
+[Sign up for a IronWorker account][1], it's free to try!
+
+[1]: http://www.iron.io/
+
+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](http://docs.iron.io).
+IronWorker can do so much more!
+
+Discussion Group
+----------------------
+
+Join the discussion group at: https://groups.google.com/forum/#!forum/ironworker-users

data/VERSION.yml

@@ -0,0 +1,5 @@
+---
+:major: 2
+:minor: 1
+:patch: 0
+:build: 

data/lib/generators/iron_worker/iron_worker_generator.rb

@@ -0,0 +1,13 @@
+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/iron_worker.rb

@@ -0,0 +1,49 @@
+require_relative 'iron_worker/utils'
+require_relative 'iron_worker/service'
+require_relative 'iron_worker/base'
+require_relative 'iron_worker/config'
+require_relative 'iron_worker/used_in_worker'
+
+
+module IronWorker
+  @@logger = Logger.new(STDOUT)
+  @@logger.level = Logger::INFO
+
+
+  class << self
+    attr_accessor :config,
+                  :service
+
+    def configure()
+      yield(config)
+      if config && config.token
+        IronWorker.service ||= Service.new(config.token, :config=>config)
+      else
+        @@logger.warn "No token specified in configure, be sure to set it!"
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def logger
+      @@logger
+    end
+
+    def api_version
+      2
+    end
+  end
+
+end
+
+if defined?(Rails)
+#  puts 'Rails=' + Rails.inspect
+#  puts 'vers=' + Rails::VERSION::MAJOR.inspect
+  if Rails::VERSION::MAJOR == 2
+    require_relative 'iron_worker/rails2_init.rb'
+  else
+    require_relative 'iron_worker/railtie'
+  end
+end

data/lib/iron_worker/api.rb

@@ -0,0 +1,242 @@
+require 'rest_client'
+require_relative 'uber_client'
+
+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]
+
+        @base_url = "#{@scheme}://#{@host}:#{@port}/#{@version}"
+
+        @uber_client = Uber::Client.new
+
+      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

@@ -0,0 +1,432 @@
+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}")
+        @merged_mailers[basename] = {:name=>basename, :path_to_templates=>path_to_templates, :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.
+      #
+      # file: This is the path to the file, just like merge.
+      # class_name: eg: 'MyWorker'.
+      def merge_worker(file, class_name)
+#        puts 'merge_worker in ' + self.name
+        ret = merge(file)
+        ret[:class_name] = class_name
+        #[File.expand_path(file), class_name]
+        @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'
+      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?
+      !is_remote?
+    end
+
+    def is_remote?
+      false
+    end
+
+    # will return after job has completed or errored out.
+    # Returns status.
+    # todo: add a :timeout option
+    def wait_until_complete
+      check_service
+      IronWorker.service.wait_until_complete(self.task_id)
+    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.get_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={})
+      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)
+        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, :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