Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2016 E1624 Compose functional tests for Suggest topics of student functionality

2016-04-15T00:48:18Z

Schen35: /* Capybara Based Test Design */

This wiki page is for the description of changes made under E1624 Final project design assignment for Spring 2016, CSC/ECE 517.

==Problem Statement==

===What it does===
Suggested topic functionality is designed for students to suggest topics they interested in. An assignment can be set up to allow students to suggest topics at the discretion of the instructor. Then, students can suggest topics, and add related descriptions. The proposer can state that (s)he wants to work on the suggested topic. When the instructor approves a suggested topic, if the proposer wanted to work on it, it is assigned to the proposer. Otherwise, it is placed on the signup sheet for anyone to reserve. The purpose of suggested topic is to make the writing assignment more personalized.
===What’s wrong with it===
Currently, there is no functional test for student's topic suggestion function.

===What needs to be done===
*Understand the flow of the suggested topic function.
*Do not use the development DB, otherwise the tests will not pass on TravisCI.
*Create RSpec file in /spec/features/ folder.
*Use fixtures to create the assignment record and any other records such as participant records in test DB.
*Use Capybara to write functional tests for these three scenarios.
**One team is on the waitlist. They sent a suggestion for new topic and they want to choose their suggested topic. After their suggested topic is approved, they should leave the waitlist and hold their suggested topic;
**One team is holding a topic. They sent a suggestion for new topic and they want to choose their suggested topic. After their suggested topic is approved and they choose to switch to suggested topic, they will hold suggested topic and their old topic will be released. And if another team is in waitlist of that old topic, that team should hold the old topic now;
**One team is holding a topic. They sent a suggestion for new topic and they do not want to work on their suggested topic. After their suggested topic is approved and they choose to public suggested topic, they will still hold their old topic. Their suggested topic will be added in sign-up sheet.
*Create multiple tests to check valid and invalid cases.
 

==Capybara Based Test Design==
To test the functionality of student's suggest topic, we plan to use Capybara to write the test code for each step listed below, covering all three scenarios.
(We wish to add some UI screenshots for each step, for better illustration, but seems the file upload function of this expertiza wiki is available for student user level so far.)

===Prerequisites===
In the project, we assume that an instructor account ''instructor6'' and a student account ''student11'' is already created.
===Flow of suggest topic function===
====Step 1 Use instructor to add a course with topic suggestion enabled====
First step is to login with the instructor account (''instructor6'' here), and then create a course with the '''new public assignment''' function.
We will create the assignment and edit the topic feature to '''enable the topic suggestions''' function for student, where in the UI, it means select the "Allow topic suggestions from students?" checkbox.
Also, to test the second and third scenarios that the student already hold a topic, we will '''add a new topic''' with 1 slot for testing the later two scenarios.
After all above are done, the course just created can be saved to the test database.

In this step, we need to write two functional tests: one is to check whether the course can be added and does the added one have topic suggestion enabled, the other one is to check whether the topic is added by instructor with 1 slot.
[[File:Csc517-final-design-yj-2.png]]

 

====Step 2 Add student to the course====
After the course is added, the student (''student11'' for this test project) will be '''added as participants''' to the course.
For UI test, it should be entering "student11" as the participant name with the "participant" choice selected then click "add" button.

In this step, we need to test whether the student, named ''student11'', is added to the course correctly.

[[File:Csc517-final-design-yj-3.png]]

 

====Step 3.1 Use student to suggest a new topic without holding any topic====
For the first scenario, which the student does not holding any topic, we should test after login with ''student11'' account and choose the assignment just created by ''instructor6''.
Then, we will '''suggest a topic''' with the choice of "Yes" for the question '''Do you wish to work on this topic?''' and '''submit''' the new topic suggestion.

In this step, we need to write the function test to check whether the new topic is added and the student is willing to work on this topic if it is approved.

[[File:Csc517-final-design-yj-41.png]]

 

====Step 3.2 Use student to suggest a new topic holding a topic and wish to switch ====
For the second scenario, we should first let the student login and '''Signup''' the only topic created by the instructor in the Signup sheet.
Then do the same thing as depict in Step 3.1.

In this step, we need to write two function tests: one is to check whether the student is already on the student list the topic, and the other one is to check whether the topic's available slots of the topic is 1 and the max number of slots is 2.
[[File:Csc517-final-design-yj-5.png]]

 

====Step 3.3 Use student to suggest a new topic holding a topic and do '''NOT''' wish to switch ====
For the third scenario, we should do the same thing as introduced in Step 3.2, but the only difference is to select the choice of "No" for the question '''Do you wish to work on this topic?'''.

In this step, we also need to write two function tests: one is to check whether the student is already on the student list the topic, and the other one is to check whether the topic's available slots of the topic is 0 now and the max number of slots is 2.

[[File:Csc517-final-design-yj-6.png]]

 

====Step 4 Approve/Reject the suggested topic====
The approve/reject functions should also be tested by using the ''instructor6'' account. After login the instructor account, use the assignment '''view suggestions''' function to '''view''' and then '''approve/reject''' the new suggested topic.

In this step, we need to write two function tests: one is to check whether the '''Signup sheet''' does have/not have the suggested topic if it is approved/rejected, the other one is to check whether in the student '''suggest new topics''', the topic suggested by ''student11'' is indeed approved/rejected accordingly.

Note that, this step is the final test step for the case of suggested topic is rejected. The following 3 possible step 5 is for the case the suggested topic is approved.

[[File:Csc517-final-design-yj-9.png]]

 

====Step 5.1 Student did not holding any topic before suggestion====
In addition to step 4, since the choice is "Yes" for willing to work on this topic when the student suggested, we will also need to test whether the student is already on the list of the new suggested topic and the number of available slot of the new suggested topic is 0.

 

====Step 5.2 Student held a topic but '''NOT''' wish to switch to new suggested topic====
For the student was holding a topic and do not want to switch, we need to write two tests: one is to check whether the student is still enrolled on the previous holding topic, and the other one is to confirm that the available slot of the new topic suggested topic is 1.

[[File:Csc517-final-design-yj-7.png]]

 

====Step 5.3 Student held a topic and wish to switch to new suggested topic====
For the student was holding a topic, coupled with the test written for Step 5.1, there is another test need to be written to check whether the slot of the previous held topic is increased by one.

[[File:Csc517-final-design-yj-8.png]]

CSC/ECE 517 Spring 2016 E1624 Compose functional tests for Suggest topics of student functionality

2016-04-15T00:44:48Z

Schen35: /* Design of solution */

Active Job

2016-02-06T03:28:04Z

Schen35: /* Background Mail Sender */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-06T03:17:49Z

Schen35: /* Introduction */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-06T03:15:53Z

Schen35: /* 2. Resque setupRedis “Download Redis” 2016 */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-05T22:29:19Z

Schen35: /* 1. Getting started with Rails:GitHub “Welcome to Rails” 2015 */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:28:59Z

Schen35: /* Background Mail Sender */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:28:38Z

Schen35: /* Examples */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:11:29Z

Schen35: /* Examples */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.
Visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:08:39Z

Schen35: /* 2. Resque setup */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.
Visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:06:30Z

Schen35: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.
Visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T22:05:51Z

Schen35: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.
Visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:41:51Z

Schen35: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T16:22:55-05:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:18:16Z

Schen35: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:17:32Z

Schen35: /* How to use */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
<pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:16:17Z

Schen35: /* 4. Active Job: */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref name= "Active-Job-Basics"/>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics"/> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
<pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:15:58Z

Schen35: /* Examples */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref name= "Active-Job-Basics"/>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics"/> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job:====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
<pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

=='''References'''==
<references/>

Active Job

2016-02-05T21:14:57Z

Schen35: /* Play with Queues */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref name= "Active-Job-Basics"/>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics"/> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

==== 4. Active Job:====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job follow_up_email
</pre>

In the generated file app/jobs/user_registered_mailer_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/follow_up_email_job.rb

class FollowUpEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.follow_up_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job follow_up_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
FollowUpEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the mailer, we need a “mailcatcher” for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { :address => "localhost", :port => 1025 }
end
<pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

In your browser, view the Resque dashboard at http:/http://0.0.0.0:5678. In another tab, visit http://127.0.0.1:1080 to see the Mailcatcher dashboard.

One minute later you can see following in Resque scheduler:
<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in mailcatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>
Yeah!

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

4. Active Job:
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job to

=='''References'''==
<references/>

Active Job

2016-02-05T20:14:27Z

Schen35: /* Examples */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup ====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can getting Redis with [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis with:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Windows, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will creat a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def follow_up_email(email)
mail(
to: email,
subject: 'We hope you are enjoying our app'
)
end
end
</pre>
In app/views/user_mailer/follow_up_email.text
<pre>
#app/views/user_mailer/follow_up_email.text

Hey, we saw that you recently signed up for our app.
We hope you're enjoying it!
</pre>

4. Active Job:
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job to

=='''References'''==
<references/>

Active Job

2016-02-03T20:00:36Z

Schen35: /* Examples */

Active Job

2016-02-02T20:54:16Z

Schen35: /* Examples */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
1. Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref>
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>

=='''References'''==
<references/>

Active Job

2016-02-02T20:52:51Z

Schen35: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install the Active Job into your computer:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a job in app/jobs, with the name “update_wiki”, by doing the following. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by create a job as following: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
Getting started with Rails:<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref>
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob” is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>

=='''References'''==
<references/>

Active Job

2016-02-02T19:46:16Z

Schen35: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

Active Job

2016-01-31T14:49:45Z

Schen35: /* How to use Rails Guides “Active Job Basics” 2014 */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
Active Job can be installed with latest version using RubyGems:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. The following will create a job in app/jobs, with the name “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
You can also create a job that will run on a specific queue: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
You could create your own file inside of app/jobs, without using a generator. In Rails 4.2 an ActiveJob inherits from ActiveJob::Base. In Rails 5.0 this behavior has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0 you need to create an application_job.rb file in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method which is called when the job was first enqueued. You can define perform with as many arguments as you want. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, some queueing backends allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job has built-in adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> If no adapter is set, the job is immediately executed. 
You can set your queueing backend at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
You can prefix the queue name for all your jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

The default queue name prefix delimiter is '_'. This can be changed by setting config.active_job.queue_name_delimiter in application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
config.active_job.queue_name_delimiter = '.'
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production.low_priority on your
# production environment and on staging.low_priority on your staging
# environment
</pre>
If you want more control on what queue a job will be run you can pass a :queue option to #set:
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>
To control the queue from the job level you can pass a block to #queue_as. The block will be executed in the job context (so you can access self.arguments) and you must return the queue name:
<pre>
class ProcessVideoJob < ActiveJob::Base
queue_as do
video = self.arguments.first
if video.owner.premium?
:premium_videojobs
else
:videojobs
end
end

def perform(video)
# do process video
end
end

ProcessVideoJob.perform_later(Video.last)

</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

=='''References'''==
<references/>

Active Job

2016-01-31T14:44:03Z

Schen35: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>'''==
This section will guide to creating a job and and how to enqueuing the job. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
Active Job can be installed with latest version using RubyGems:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. The following will create a job in app/jobs, with the name “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
You can also create a job that will run on a specific queue: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
You could create your own file inside of app/jobs, without using a generator. In Rails 4.2 an ActiveJob inherits from ActiveJob::Base. In Rails 5.0 this behavior has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0 you need to create an application_job.rb file in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method which is called when the job was first enqueued. You can define perform with as many arguments as you want. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, some queueing backends allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job has built-in adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> If no adapter is set, the job is immediately executed. 
You can set your queueing backend at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
You can prefix the queue name for all your jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

The default queue name prefix delimiter is '_'. This can be changed by setting config.active_job.queue_name_delimiter in application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
config.active_job.queue_name_delimiter = '.'
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production.low_priority on your
# production environment and on staging.low_priority on your staging
# environment
</pre>
If you want more control on what queue a job will be run you can pass a :queue option to #set:
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>
To control the queue from the job level you can pass a block to #queue_as. The block will be executed in the job context (so you can access self.arguments) and you must return the queue name:
<pre>
class ProcessVideoJob < ActiveJob::Base
queue_as do
video = self.arguments.first
if video.owner.premium?
:premium_videojobs
else
:videojobs
end
end

def perform(video)
# do process video
end
end

ProcessVideoJob.perform_later(Video.last)

</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

=='''References'''==
<references/>

Active Job

2016-01-31T14:42:33Z

Schen35: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. <ref>http://guides.rubyonrails.org/active_job_basics.html</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters<ref>http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html</ref>====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This section will guide to creating a job and and how to enqueuing the job. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
Active Job can be installed with latest version using RubyGems:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. The following will create a job in app/jobs, with the name “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
You can also create a job that will run on a specific queue: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
You could create your own file inside of app/jobs, without using a generator. In Rails 4.2 an ActiveJob inherits from ActiveJob::Base. In Rails 5.0 this behavior has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0 you need to create an application_job.rb file in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method which is called when the job was first enqueued. You can define perform with as many arguments as you want. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, some queueing backends allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job has built-in adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> If no adapter is set, the job is immediately executed. 
You can set your queueing backend at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
You can prefix the queue name for all your jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

The default queue name prefix delimiter is '_'. This can be changed by setting config.active_job.queue_name_delimiter in application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
config.active_job.queue_name_delimiter = '.'
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production.low_priority on your
# production environment and on staging.low_priority on your staging
# environment
</pre>
If you want more control on what queue a job will be run you can pass a :queue option to #set:
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>
To control the queue from the job level you can pass a block to #queue_as. The block will be executed in the job context (so you can access self.arguments) and you must return the queue name:
<pre>
class ProcessVideoJob < ActiveJob::Base
queue_as do
video = self.arguments.first
if video.owner.premium?
:premium_videojobs
else
:videojobs
end
end

def perform(video)
# do process video
end
end

ProcessVideoJob.perform_later(Video.last)

</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

=='''References'''==
<references/>

Active Job

2016-01-31T14:30:52Z

Schen35: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. [http://guides.rubyonrails.org/4_2_release_notes.html] Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html]====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This section will guide to creating a job and and how to enqueuing the job. <ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref> 
=== Download ===
Active Job can be installed with latest version using RubyGems:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. The following will create a job in app/jobs, with the name “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
You can also create a job that will run on a specific queue: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
You could create your own file inside of app/jobs, without using a generator. In Rails 4.2 an ActiveJob inherits from ActiveJob::Base. In Rails 5.0 this behavior has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0 you need to create an application_job.rb file in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method which is called when the job was first enqueued. You can define perform with as many arguments as you want. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, some queueing backends allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job has built-in adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref> If no adapter is set, the job is immediately executed. 
You can set your queueing backend at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
You can prefix the queue name for all your jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

The default queue name prefix delimiter is '_'. This can be changed by setting config.active_job.queue_name_delimiter in application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
config.active_job.queue_name_delimiter = '.'
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production.low_priority on your
# production environment and on staging.low_priority on your staging
# environment
</pre>
If you want more control on what queue a job will be run you can pass a :queue option to #set:
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>
To control the queue from the job level you can pass a block to #queue_as. The block will be executed in the job context (so you can access self.arguments) and you must return the queue name:
<pre>
class ProcessVideoJob < ActiveJob::Base
queue_as do
video = self.arguments.first
if video.owner.premium?
:premium_videojobs
else
:videojobs
end
end

def perform(video)
# do process video
end
end

ProcessVideoJob.perform_later(Video.last)

</pre>

All the code snippets are referred from the source:<ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref>

=='''References'''==
<references/>

Active Job

2016-01-31T14:29:03Z

Schen35: /* Introduction */

== Introduction ==
Active Job is a framework help developers writing codes and run them on the background automatically under different scenarios. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. It’s a interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. [http://guides.rubyonrails.org/4_2_release_notes.html] Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Active Job adapters[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html]====
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This section will guide to creating a job and and how to enqueuing the job. <ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref> 
=== Download ===
Active Job can be installed with latest version using RubyGems:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process which is inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. The following will create a job in app/jobs, with the name “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
You can also create a job that will run on a specific queue: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
You could create your own file inside of app/jobs, without using a generator. In Rails 4.2 an ActiveJob inherits from ActiveJob::Base. In Rails 5.0 this behavior has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0 you need to create an application_job.rb file in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class looks like:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method which is called when the job was first enqueued. You can define perform with as many arguments as you want. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, some queueing backends allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job has built-in adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref> If no adapter is set, the job is immediately executed. 
You can set your queueing backend at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
You can prefix the queue name for all your jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

The default queue name prefix delimiter is '_'. This can be changed by setting config.active_job.queue_name_delimiter in application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
config.active_job.queue_name_delimiter = '.'
end
end

# app/jobs/guests_cleanup.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production.low_priority on your
# production environment and on staging.low_priority on your staging
# environment
</pre>
If you want more control on what queue a job will be run you can pass a :queue option to #set:
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>
To control the queue from the job level you can pass a block to #queue_as. The block will be executed in the job context (so you can access self.arguments) and you must return the queue name:
<pre>
class ProcessVideoJob < ActiveJob::Base
queue_as do
video = self.arguments.first
if video.owner.premium?
:premium_videojobs
else
:videojobs
end
end

def perform(video)
# do process video
end
end

ProcessVideoJob.perform_later(Video.last)

</pre>

All the code snippets are referred from the source:<ref> Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014] </ref>