resque | backed Ruby library for creating background jobs | Job Scheduling library

resque comes with a built-in server. You do not need resque-web and it seems it is not maintained (last commit was on 2018).

Let's try this:

It's not working because ActiveJob doesn't support the objects. To make it accessible you have to either convert it into json string and then deserialise in the mailer method.

Try sending the object as json string and retrieve the id value, then use:

Don't do that.

It's a bad design to schedule many jobs for a few days or weeks later, especially when they perform a critical task.

Why?

Mainly because the scheduled job's date is not stored in your application database but another one, most of the time in Redis. In the majority of cases, it is not included in the backup. So the day you need to restore a backup, you'll lose all pending scheduled job. All the accounts that were pending for the last subscription period to end may remain open.

The safest solution is to rely on a database field holding the actual end of the subscription date. Let's name it subscription_ends_on. If your user unsubscribes on April 12th, you set subscription_ends_on with the value "March 1rst".

Then you create a background job that runs every day at midnight and unsubscribe all accounts where subscription_ends_on is not null and is less than or equal to today.

Update:

It looks like it was a problem with my post-Bower configuration (I migrated from Bower --> Yarn) I was able to solve Sprockets errors by adding this line to my assets.rb:

Rails.application.config.assets.paths << Rails.root.join('node_modules')

and by running yarn add for files that Sprockets could not locate.

I also made the following updates to old package names in my `application.rb'

The problem with resque-status: its last commit (to date, for 0.5.0 version) was done 5 years ago, so is a pretty outdated and unmaintained gem.
As long as this isn't updated, you should try luck with some of the forks. This looks promising, as it update the version restrictions in the gemspec, so try adding to your Gemfile:

I don't know why, but this is the solution. Rather than running:

You have it right. As the main Resque documentation states:

Resque doesn't support numeric priorities but instead uses the order of queues you give it. We call this list of queues the "queue list."

Let's say we add a warm_cache queue in addition to our file_serve queue. We'd now start a worker like so:

$ QUEUES=file_serve,warm_cache rake resque:work

When the worker looks for new jobs, it will first check file_serve. If it finds a job, it'll process it then check file_serve again. It will keep checking file_serve until no more jobs are available. At that point, it will check warm_cache. If it finds a job it'll process it then check file_serve (repeating the whole process).

In this way you can prioritize certain queues.

Note that, in a resque-pool setup, each process that spawns will follow its own priority (so in the example config it's possible bar jobs will get processed before foo jobs if the process that only processes bar is free while the others are busy). That's a feature, though, not a bug!

As for how you can test it, simply enqueue a bunch of jobs in each queue and watch as they get processed in resque-web (or the logs).

You have many options

1. The simplest one is creating a rake task and setting up a cron job to call this time every minute or something like that. If you call it every 24h you may end up with posts staying for up to 47h.

2. You can use delayed jobs in two ways

   2.1 In an after_create callback, set a job to delete the post after 24 hours. Something like this handle_asynchronously :in_the_future, run_at: Proc.new { 24.hours.from_now }

   2.2 Using delayed_job_recurring gem to do the same thing in option one, but without the need of using cron

Edit: I would use option 2.1 since it's the simplest one and easier to maintain, the only downside is that it will create a job for every post, but that shouldn't be a problem even with a million posts a day

resque worker will keep on polls redis queues for pending jobs. So, we need to pass queue names as args to resque task while starting the task. QUEUE=* is doing the same here.

So, here your question can be breakdown to 2 parts,

1. what is the purpose of QUEUE
2. What is the purpose of *

QUEUE:

In ruby we can do this in 4 ways.

1. Rake args:

   rake resque:work[*]

   For this to work resque task should have the following convention