async_request 0.0.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3c0c80e8b0b2ebd22e02a571b7688b13d3cc23d
-  data.tar.gz: 723d1a492e3baa01fae0fa8825b1e8fa581e85da
+  metadata.gz: 45805a4b75fb35b1facc6480ebba378982a03d2a
+  data.tar.gz: 8278641e1d569f0c39d577281dd595d1a1b2b687
 SHA512:
-  metadata.gz: 656bb7dd04557c465fe180b724137cbf275be654cd895864828e868b0dbb1a2d2bf52e4c2bf4aae326f4f3d14ae6814029be09091611cfc46d967402202555ba
-  data.tar.gz: b37b45bc6a96f28cf6731abf9af02a7c4af0be031f92ae8195b94045d137e5a6942c731c482281d17f7e791ea6ae967e8835b33468bf7cfb590b10d3fd97debe
+  metadata.gz: a043dd82166c8a01b2e6a471da23b29c475a307fdcfe2ba5400365688c7c31d7c805cbd1e65bf855602adc5fb7726be2024330b68a5feb43691718a58c73e8bd
+  data.tar.gz: 49cbb5615b4adf3c1d87d118dc871270dfa3c530f5687cbe55834b77339444ccd816a1be605dade3fa893effebf6feaccb8dbb04b4c9f65ad32740d95767f666

data/app/controllers/async_request/jobs_controller.rb

@@ -1,19 +1,49 @@
+require 'jwt'
+
 module AsyncRequest
   class JobsController < ActionController::Base
     def show
-      job = Job.find_by(uid: params[:id])
-      return head :not_found unless job.present?
-      job.processed? ? render_finished_job(job) : render_pending(job)
+      return render_invalid_token unless valid_token?
+      job = Job.find_by(id: token[:job_id])
+      return head :not_found if job.blank?
+      job.finished? ? render_finished_job(job) : render_pending
     end
 
     private
 
-    def render_pending(job)
-      render json: { status: job.status }, status: :accepted
+    def valid_token?
+      token[:job_id].present? && Time.zone.now.to_i < token[:expires_in]
+    end
+
+    def token
+      @token ||= decode_token
+    end
+
+    def decode_token
+      HashWithIndifferentAccess.new(
+        JsonWebToken.decode(
+          request.headers[AsyncRequest.config[:request_header_key]].split(' ').last
+        )
+      )
+    rescue StandardError
+      {}
+    end
+
+    def render_invalid_token
+      render json: { errors: [{ message: 'Invalid token' }] }, status: :bad_request
+    end
+
+    def render_pending
+      head :accepted
     end
 
     def render_finished_job(job)
-      render json: JSON.parse(job.response), status: job.status_code
+      render json: {
+        status: job.status,
+        response: {
+          status_code: job.status_code, body: job.response
+        }
+      }, status: :ok
     end
   end
 end

data/app/models/async_request/job.rb

@@ -1,6 +1,53 @@
 module AsyncRequest
-  class Job < ActiveRecord::Base
+  class Job < ActiveRecord::Base # rubocop:disable Rails/ApplicationRecord
     serialize :params, Array
-    enum status: [:waiting, :processing, :processed]
+    enum status: { waiting: 0, processing: 1, processed: 2, failed: 3 }
+
+    def self.create_and_enqueue(worker_class, *params)
+      raise ArgumentError if worker_class.nil?
+      create(
+        worker: worker_class,
+        params: params,
+        status: statuses[:waiting],
+        uid: SecureRandom.uuid
+      ).tap { |job| JobProcessor.perform_async(job.id) }
+    end
+
+    def token
+      @token ||= JsonWebToken.encode(id)
+    end
+
+    def successfully_processed!(response, status_code)
+      Rails.logger.info("Processing finished successfully for job with id=#{id}")
+      update_attributes!(
+        status: :processed,
+        status_code: map_status_code(status_code),
+        response: response.to_s
+      )
+    end
+
+    def processing!
+      Rails.logger.info("Processing job with id=#{id}")
+      super
+    end
+
+    def finished?
+      processed? || failed?
+    end
+
+    def finished_with_errors!(error)
+      Rails.logger.info("Processing failed for job with id=#{id}")
+      Rails.logger.info(error.message)
+      Rails.logger.info(error.backtrace.inspect)
+      update_attributes!(status: :failed, status_code: 500,
+                         response: { error: error.message }.to_json)
+    end
+
+    private
+
+    def map_status_code(status_code)
+      return Rack::Utils::SYMBOL_TO_STATUS_CODE[status_code] if status_code.is_a?(Symbol)
+      status_code.to_i
+    end
   end
 end

data/app/poros/async_request/json_web_token.rb

@@ -0,0 +1,26 @@
+require 'jwt'
+require 'time'
+
+module AsyncRequest
+  class JsonWebToken
+    def self.encode(job_id, expiration = AsyncRequest.config[:token_expiration].to_i)
+      JWT.encode(
+        {
+          job_id: job_id,
+          expires_in: (Time.zone.now + expiration).to_i
+        },
+        AsyncRequest.config[:encode_key],
+        AsyncRequest.config[:sign_algorithm]
+      )
+    end
+
+    def self.decode(token)
+      JWT.decode(
+        token,
+        AsyncRequest.config[:decode_key],
+        true,
+        algorithm: AsyncRequest.config[:sign_algorithm]
+      ).first
+    end
+  end
+end

data/app/workers/async_request/job_processor.rb

@@ -6,12 +6,12 @@ module AsyncRequest
     def perform(id)
       job = Job.find(id)
       job.processing!
-      status, response = job.worker.constantize.new.execute(*job.params)
-      job.update_attributes!(
-        status: Job.statuses[:processed],
-        status_code: status,
-        response: response.to_json
-      )
+      begin
+        status, response = job.worker.constantize.new.execute(*job.params)
+        job.successfully_processed!(response, status)
+      rescue StandardError => e
+        job.finished_with_errors! e
+      end
     end
   end
 end

data/config/routes.rb

@@ -1,3 +1,3 @@
 AsyncRequest::Engine.routes.draw do
-  resources :jobs, only: [:show]
+  resource :job, only: [:show]
 end

data/lib/async_request.rb

@@ -1,7 +1,14 @@
 require 'async_request/engine'
 
 module AsyncRequest
+  VALID_ALGORITHMS = %w[HS256 RS256].freeze
+
   @config = {
+    sign_algorithm: 'HS256',
+    encode_key: nil,
+    decode_key: nil,
+    token_expiration: 86_400,
+    request_header_key: 'X-JOB-AUTHORIZATION',
     queue: 'default',
     retry: false
   }
@@ -10,6 +17,27 @@ module AsyncRequest
     yield self
   end
 
+  def self.sign_algorithm=(sign_algorithm)
+    raise ArgumentError unless VALID_ALGORITHMS.include?(sign_algorithm)
+    @config[:sign_algorithm] = sign_algorithm
+  end
+
+  def self.encode_key=(encode_key)
+    @config[:encode_key] = encode_key
+  end
+
+  def self.decode_key=(decode_key)
+    @config[:decode_key] = decode_key
+  end
+
+  def self.token_expiration=(token_expiration)
+    @config[:token_expiration] = token_expiration
+  end
+
+  def self.request_header_key=(request_header_key)
+    @config[:request_header_key] = request_header_key
+  end
+
   def self.queue=(queue)
     @config[:queue] = queue
   end

data/lib/async_request/engine.rb

@@ -1,11 +1,12 @@
 require 'sidekiq'
+
 module AsyncRequest
   class Engine < ::Rails::Engine
     isolate_namespace AsyncRequest
 
     initializer 'async_request', before: :load_config_initializers do |app|
       Rails.application.routes.append do
-        mount AsyncRequest::Engine, at: '/async_request'
+        mount AsyncRequest::Engine, at: '/async_request', as: 'async_request'
       end
 
       unless app.root.to_s.match root.to_s

data/lib/async_request/version.rb

@@ -1,3 +1,3 @@
 module AsyncRequest
-  VERSION = '0.0.7'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/generators/async_request_generator.rb

@@ -4,8 +4,11 @@ class AsyncRequestGenerator < Rails::Generators::Base
   source_root File.expand_path('../../templates', __FILE__)
 
   def copy_initializer_file
-    file_name = 'create_async_request_jobs.rb'
-    now = DateTime.current.strftime('%Y%m%d%H%M%S')
-    copy_file file_name, "db/migrate/#{now}_#{file_name}"
+    migration_file = 'create_async_request_jobs.rb'
+    now = Time.zone.now.strftime('%Y%m%d%H%M%S') # rubocop:disable Style/FormatStringToken
+    copy_file migration_file, "db/migrate/#{now}_#{migration_file}"
+
+    config_file = 'async_request.rb'
+    copy_file config_file, "config/initializers/#{config_file}"
   end
 end

data/lib/templates/async_request.rb

@@ -0,0 +1,5 @@
+AsyncRequest.configure do |config|
+  config.encode_key = Rails.application.secrets.secret_key_base
+  config.decode_key = Rails.application.secrets.secret_key_base
+  config.token_expiration = 1.day
+end

data/lib/templates/create_async_request_jobs.rb

@@ -1,5 +1,5 @@
 class CreateAsyncRequestJobs < ActiveRecord::Migration
-  def change
+  def change # rubocop:disable Metrics/MethodLength
     create_table :async_request_jobs do |t|
       t.string :worker
       t.integer :status

data/spec/controllers/async_request/jobs_controller_spec.rb

@@ -1,46 +1,85 @@
 require 'spec_helper'
 
-module AsyncRequest
-  describe JobsController do
-    routes { AsyncRequest::Engine.routes }
-
-    describe '#show' do
-      context 'when there is no job with the given id' do
-        let!(:job) { FactoryGirl.create(:async_request_job, :waiting) }
-        it 'returns 404' do
-          get :show, id: job.uid + 'ABC'
-          expect(response.status).to eq(404)
-        end
-      end
-
-      context 'when the job exists but it is in a waiting status' do
-        let!(:job) { FactoryGirl.create(:async_request_job, :waiting) }
-        it 'returns 202' do
-          get :show, id: job.uid
-          expect(response.status).to eq(202)
-        end
-      end
-
-      context 'when the job exists but it is in a processing status' do
-        let!(:job) { FactoryGirl.create(:async_request_job, :processing) }
-        it 'returns 202' do
-          get :show, id: job.uid
-          expect(response.status).to eq(202)
-        end
-      end
-
-      context 'when the job exists and has finished' do
-        let!(:job) { FactoryGirl.create(:async_request_job, :processed) }
-
-        it 'returns the saved status code' do
-          get :show, id: job.uid
-          expect(response.status).to eq(job.status_code)
-        end
-
-        it 'returns the saved status code' do
-          get :show, id: job.uid
-          expect(response_body).to eq(JSON.parse(job.response))
-        end
+describe AsyncRequest::JobsController do
+  routes { AsyncRequest::Engine.routes }
+
+  describe '#show' do
+    let(:job) { create(:async_request_job, status) }
+    let(:job_id) { job.id }
+    let(:job_token) { AsyncRequest::JsonWebToken.encode(job_id) }
+    let(:status) { :waiting }
+
+    before { request.headers['X-JOB-AUTHORIZATION'] = "Bearer #{job_token}" }
+
+    context 'when there is no job with the given id' do
+      let(:job_id) { 1000 }
+
+      it 'returns status not found' do
+        get :show
+        expect(response).to have_http_status :not_found
+      end
+    end
+
+    context 'when receiving an expired token' do
+      let(:job_token) do
+        AsyncRequest::JsonWebToken.encode(create(:async_request_job).id, (1.day * -1).to_i)
+      end
+
+      it 'returns status bad request' do
+        get :show
+        expect(response).to have_http_status :bad_request
+      end
+    end
+
+    context 'when the job exists but it is in a waiting status' do
+      it 'returns status accepted' do
+        get :show
+        expect(response).to have_http_status :accepted
+      end
+    end
+
+    context 'when the job exists but it is in a processing status' do
+      let(:status) { :processing }
+
+      it 'returns status accepted' do
+        get :show
+        expect(response).to have_http_status :accepted
+      end
+    end
+
+    context 'when the job exists and has finished' do
+      let(:status) { :processed }
+
+      it 'returns the saved status code' do
+        get :show
+        expect(response).to have_http_status :ok
+      end
+
+      it 'returns as body job\'s status code and response' do
+        get :show
+        controller_response = {
+          'status' => 'processed',
+          'response' => { 'status_code' => job.status_code, 'body' => job.response }
+        }
+        expect(response_body).to eq(controller_response)
+      end
+    end
+
+    context 'when the job exists and has a failed status' do
+      let(:status) { :failed }
+
+      it 'returns the saved status code' do
+        get :show
+        expect(response).to have_http_status :ok
+      end
+
+      it 'returns as body job\'s status code and response' do
+        get :show
+        controller_response = {
+          'status' => 'failed',
+          'response' => { 'status_code' => job.status_code, 'body' => job.response }
+        }
+        expect(response_body).to eq(controller_response)
       end
     end
   end

data/spec/controllers/dummy_controller_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe DummyController, type: :controller do
+  describe '.async_option_1' do
+    subject { post :async_option_1 }
+
+    it 'returns status code accepted' do
+      subject
+      expect(response).to have_http_status(:accepted)
+    end
+
+    it 'creates the job model' do
+      expect { subject }.to change { AsyncRequest::Job.count }.by(1)
+    end
+
+    it 'returns the url' do
+      subject
+      expect(response_body['url']).to be_present
+    end
+
+    it 'returns the token' do
+      subject
+      expect(response_body['token']).to be_present
+    end
+  end
+
+  describe '.async_option_2' do
+    subject { post :async_option_2 }
+
+    it 'returns status code accepted' do
+      subject
+      expect(response).to have_http_status(:accepted)
+    end
+
+    it 'creates the job model' do
+      expect { subject }.to change { AsyncRequest::Job.count }.by(1)
+    end
+
+    it 'returns the token' do
+      subject
+      expect(response_body['token']).to be_present
+    end
+
+    it 'returns the location header' do
+      subject
+      expect(response.headers['Location']).to be_present
+    end
+  end
+end