async_endpoint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c76ec1af2af2996551f67ab9d709bc39752b61f
+  data.tar.gz: 52cd077da34e1a3dc2fa448adbd9fbc64ce4893a
+SHA512:
+  metadata.gz: 91f26c554c8e2df7812ca5ce6136a9363d5d9ecb752e34c29c46e30a2cf9c8e73a39aa777cc6eb0d2e8615fb9814d97c8c8b1d5f0f3e729181f6bc1b4a016b32
+  data.tar.gz: ce94a3b0085772b0118c1d516c6072d191865a0d891c96f862524b0ad7c36d73194e26bf950a415d4a9c0e96783ffe69a9ec3de1981695c5a87936ecd57eb599

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 mrosso10
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# Async Endpoint
+
+## Summary
+
+Often in our Rails applications we have tasks that may take a lot of time to finish, such as external API requests. This is risky to perform inside our endpoints because it blocks our threads and is not scalable. Here we provide a solution to this problem, using sidekiq to run our heavy work in background
+
+## Approach
+
+To avoid making the external requests inside our endpoints we dellegate this task to a sidekiq
+worker and later we have to check periodically the status of the sidekiq job until it is completed.
+
+The flow goes like this:
+
+1. We make an AJAX request
+2. The endpoint enqueues a Sidekiq job that executes the request to the external API. Then returns
+the `async_request_id` with "202 Accepted" HTTP status. For security reasons it also returns an `async_request_token`, that it's actually the Sidekiq job ID.
+3. We wait some time and make another AJAX request but this time sending the `async_request_id` by parameter and the `async_request_token`.
+4. The endpoint checks the status of the Sidekiq job. If it is completed returns with HTTP 200
+status code. If it is not, returns again with "202 Accepted" HTTP status and we go back to step 3.
+
+
+## Usage
+
+First we need to define a class that inherits from AsyncRequest and implements the `execute_task` 
+method. Here we will make the request to the external API. We can use parameters set in the 
+controller endpoint and we need to set the response data using setter methods.
+
+```ruby
+class MyAsyncRequest < AsyncRequest
+  def execute_task
+    @response = execute_external_request(params_hash[:param_1], params_hash[:param_2])
+    if @response.present?
+      self.some_data = @response['some_data']
+      self.another_data = @response['another_data']
+      done
+    else
+      failed 'My custom error message'
+    end
+  end
+end
+```
+
+In the controller endpoint we create an instance of our previously defined class. We can pass 
+parameters that can be used when the external request is made. Then we define two procs to handle
+both successful and failed state.
+
+```ruby
+class MyController < ActionController::Base
+  def my_endpoint
+    @async_request = MyAsyncRequest.init(self, {param_1: 'value_1', param_2: 'value_2'})
+    done_proc = proc do
+      render json: { some_data: @async_request.some_data,
+                     another_data: @async_request.another_data }
+    end
+    failed_proc = proc do
+      render json: { error: @async_request.error_message }
+    end
+    @async_request.handle(done_proc, failed_proc)
+  end
+end
+```
+
+The only thing left is the javascript code. To start an async request we simply use the
+`$.getAsyncRequest` method instead of the regular `$.get` method.
+
+```javascript
+  $.getAsyncRequest(url, optional_timeout_in_milliseconds)
+  .success(function(response) {
+    // Do some work
+  }).error(function(response) {
+    // Handle error
+  });
+```
+
+As you can see, the only difference with the regular `$.get` method is that you can pass an optional
+parameter that is the maximum time to wait for the response. If this time is reached and the request
+has not been made the error handler is dispatched.
+

data/app/assets/javascripts/async_endpoint.coffee

@@ -0,0 +1,69 @@
+JQueryXHR = ->
+  _error = null
+  _success = null
+  _complete = null
+  _arguments = null
+  successCallbacks = []
+  errorCallbacks = []
+  completeCallbacks = []
+
+  @success = (callback) ->
+    if _success
+      callback.apply this, _arguments
+    successCallbacks.push callback
+    this
+
+  @error = (callback) ->
+    if _error
+      callback.apply this, _arguments
+    errorCallbacks.push callback
+    this
+
+  @complete = (callback) ->
+    if _complete
+      callback.apply this, _arguments
+    completeCallbacks.push callback
+    this
+
+  @dispatchSuccess = ->
+    `var i`
+    _arguments = arguments
+    _complete = _success = true
+    for i of successCallbacks
+      successCallbacks[i].apply this, _arguments
+    for i of completeCallbacks
+      completeCallbacks[i].apply this, _arguments
+    return
+
+  @dispatchError = ->
+    `var i`
+    _arguments = arguments
+    _complete = _success = true
+    for i of errorCallbacks
+      errorCallbacks[i].apply this, _arguments
+    for i of completeCallbacks
+      completeCallbacks[i].apply this, _arguments
+    return
+  return
+
+
+window.jQuery.getAsyncEndpoint = (url, max_time_to_wait, async_request_id, async_request_token, jqXHR, start_time) ->
+  jqXHR = new JQueryXHR() if jqXHR == undefined
+  max_time_to_wait = 30000 if max_time_to_wait == undefined
+  start_time = Date.now() if start_time == undefined
+  time_elapsed = Date.now() - start_time
+  $.get(url, 'async_request_id': async_request_id, 'async_request_token': async_request_token)
+  .success((response, status, xhr) ->
+    if xhr.status == 202
+      if time_elapsed < max_time_to_wait
+        setTimeout (->
+          $.getAsyncEndpoint url, max_time_to_wait, response.async_request_id, response.async_request_token, jqXHR, start_time
+        ), time_elapsed * 0.4 + 1000
+      else
+        jqXHR.dispatchError()
+    else
+      jqXHR.dispatchSuccess(response, status, xhr)
+  ).error( ->
+    jqXHR.dispatchError()
+  )
+  jqXHR

data/app/models/async_endpoint/async_request.rb

@@ -0,0 +1,96 @@
+module AsyncEndpoint
+  class AsyncRequest < ActiveRecord::Base
+    enum status: [:pending, :processing, :done, :failed]
+    attr_accessor :controller
+
+    def self.init(controller, hash_params)
+      if controller.params[:async_request_id].present?
+        async_request = find(controller.params[:async_request_id])
+        unless async_request.token_is_valid(controller.params[:async_request_token])
+          fail 'Authenticity token is not valid'
+        end
+      else
+        async_request = create(params: hash_params.to_json)
+      end
+      async_request.controller = controller
+      async_request
+    end
+
+    def done
+      self.status = AsyncRequest.statuses[:done]
+    end
+
+    def failed(message = nil)
+      self.status = AsyncRequest.statuses[:failed]
+      self.error_message = message
+    end
+
+    def error_message
+      response_hash[:error_message]
+    end
+
+    def params_hash
+      return {} unless params.present?
+      JSON.parse(params).deep_symbolize_keys
+    end
+
+    def response_hash
+      return {} unless response.present?
+      JSON.parse(response).deep_symbolize_keys
+    end
+
+    def method_missing(method, *args)
+      if method.to_s.ends_with?('=')
+        key = method.to_s.chomp('=').to_sym
+        self.response = response_hash.merge(key => args.first).to_json
+      else
+        response_hash[method]
+      end
+    end
+
+    def failed_or_crashed?
+      failed? || job_failed?
+    end
+
+    def job_failed?
+      # Sidekiq::Status.failed? jid
+      false
+    end
+
+    def execute
+      execute_task
+      save
+    end
+
+    def execute_task
+      fail 'execute_task must be implemented in subclass'
+    end
+
+    def handle(done, fail)
+      return fail.call if failed_or_crashed?
+      start_worker if pending?
+      render_accepted if pending? || processing?
+      done.call if done?
+    end
+
+    def render_accepted
+      controller.instance_exec(id, jid, &render_accepted_proc)
+    end
+
+    def render_accepted_proc
+      proc do |async_request_id, jid|
+        render json: { async_request_id: async_request_id, async_request_token: jid },
+               status: :accepted
+      end
+    end
+
+    def start_worker
+      jid = AsyncEndpointWorker.perform_async(id)
+      update_attributes(jid: jid, status: AsyncRequest.statuses[:processing])
+    end
+
+    def token_is_valid(token)
+      token.present? && ActiveSupport::SecurityUtils.secure_compare(token, jid)
+    end
+  end
+end

data/app/workers/async_endpoint/async_endpoint_worker.rb

@@ -0,0 +1,10 @@
+module AsyncEndpoint
+  class AsyncEndpointWorker
+    include Sidekiq::Worker
+
+    def perform(async_request_id)
+      async_request = AsyncRequest.find(async_request_id)
+      async_request.execute
+    end
+  end
+end

data/lib/async_endpoint.rb

@@ -0,0 +1,4 @@
+require "async_endpoint/engine"
+
+module AsyncEndpoint
+end

data/lib/async_endpoint/engine.rb

@@ -0,0 +1,5 @@
+module AsyncEndpoint
+  class Engine < ::Rails::Engine
+    isolate_namespace AsyncEndpoint
+  end
+end

data/lib/async_endpoint/version.rb

@@ -0,0 +1,3 @@
+module AsyncEndpoint
+  VERSION = "0.0.1"
+end

data/lib/generators/async_endpoint_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/base'
+
+class AsyncEndpointGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  def copy_initializer_file
+    file_name = "create_async_request.rb"
+    now = DateTime.current.strftime("%Y%m%d%H%M%S")
+    copy_file file_name, "db/migrate/#{now}_#{file_name}"
+  end
+end

data/lib/generators/templates/create_async_request.rb

@@ -0,0 +1,15 @@
+class CreateAsyncRequest < ActiveRecord::Migration
+  def change
+    create_table :async_endpoint_async_requests do |t|
+      t.string :jid
+      t.integer :status, default: 0, null: false
+      t.text :response
+      t.text :params
+      t.string :type
+      
+      t.timestamps null: false
+    end
+
+    add_index :async_endpoint_async_requests, :jid, unique: true
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: async_endpoint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Martín Rosso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+description: Often in our Rails applications we have tasks that may take a lot of
+  time to finish, such as external API requests. This is risky to perform inside our
+  endpoints because it blocks our threads and is not scalable. Here we provide a solution
+  to this problem, using sidekiq to run our heavy work in background
+email:
+- mrosso10@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- app/assets/javascripts/async_endpoint.coffee
+- app/models/async_endpoint/async_request.rb
+- app/workers/async_endpoint/async_endpoint_worker.rb
+- lib/async_endpoint.rb
+- lib/async_endpoint/engine.rb
+- lib/async_endpoint/version.rb
+- lib/generators/async_endpoint_generator.rb
+- lib/generators/templates/create_async_request.rb
+homepage: https://github.com/mrosso10/async_endpoint
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Make asynchronous endpoints in your Ruby on Rails application
+test_files: []