Releases: vapor/queues
Add ability to use custom `Calendar` in `ScheduleBuilder`
This patch was authored by @dylanshine and released by @jdmcd.
This PR introduces the ability to pass a custom Calendar
to the ScheduleBuilder
.
I ran into an edge case where I have queues deployed across multiple regions and needed to schedule jobs based on specific time zones.
I also cleaned up some unused computed properties in the ScheduleBuilderTests
suite.
Update Supported Swift Versions
This patch was authored and released by @0xTim.
This removes support for Swift 5.2 and Swift 5.3, making Swift 5.4 the earliest supported version as announced
Make AsyncScheduledJob public so clients can conform to it
Added AsyncScheduledJob and cleaned up AsyncJob.
This patch was authored by @Andrewangeta and released by @jdmcd.
Allows AsyncJob
s to be added to the app via app.queues.add(...)
method.
Async Await Support via AsyncJob
This patch was authored by @jdmcd and released by @0xTim.
Adds AsyncJob
which allows you to specify a job that has async body implementations:
struct MyJobPayload: Content {
let name: String
}
struct MyAsyncJob: AsyncJob {
func dequeue(context: QueueContext, payload: MyJobPayload) async throws {
print(payload.name)
}
func error(context: QueueContext, error: Error, payload: MyJobPayload) async throws {
print(error)
}
}
// In configure.swift
app.queues.add(MyAsyncJob())
Allow delaying retires of failed job
This patch was authored by @kacperk and released by @jdmcd.
Added possibility of delaying retires of failed jobs.
Example usage
struct SomeJob: Job {
func dequeue(_ context: QueueContext, _ payload: Payload) -> EventLoopFuture<Void> {
....
}
// Exponential backoff
func nextRetryIn(attempt: Int) -> Int {
return pow(2, attempt)
}
}
Wait for notifications to be dispatched
This patch was authored and released by @jdmcd.
Fixes a race condition where a job could be marked as "running" in your notification consumer while it had actually succeeded.
Note: If you don't have any notification delegates registered this release will have no performance impact. If you are using notification delegates the dispatch
function will now wait until all notifications have been sent to return.
Fix building with Swift 5.2
This patch was authored and released by @siemensikkema.
Enables Queues to be built with Swift 5.2 again by adding missing self
where needed. Also adds a test scenario for Swift 5.2 to prevent this from breaking in the future.
Job Event Delegate Hooks
This patch was authored and released by @jdmcd.
This release adds a protocol called JobEventDelegate
which allows ends users to "hook" into the status of jobs that are being run. Each notification hook can specify a success handler, an error handler, or both.
To get started, conform an object to JobEventDelegate
and implement any of the methods you'd like:
struct MyEventDelegate: JobEventDelegate {
public func dispatched(job: JobEventData, eventLoop: EventLoop) -> EventLoopFuture<Void> {
eventLoop.future()
}
public func didDequeue(jobId: String, eventLoop: EventLoop) -> EventLoopFuture<Void> {
eventLoop.future()
}
public func success(jobId: String, eventLoop: EventLoop) -> EventLoopFuture<Void> {
eventLoop.future()
}
public func error(jobId: String, error: Error, eventLoop: EventLoop) -> EventLoopFuture<Void> {
eventLoop.future()
}
}
Then, add it in your configuration file:
app.queues.add(MyEventDelegate())
This PR also adds a bunch of trace
logging for better debugging
Allow worker count to be configured
This patch was authored and released by @tanner0101.
Adds a new workerCount
property to QueuesConfiguration
(#86, fixes #84).
This property lets you configure how many workers will be used for handling jobs. The default value is .default
which uses one worker per event loop. You can set a custom number of workings using .custom(_:)
or an integer literal.
// Use two workers for handling jobs.
app.queues.configuration.workerCount = 2
Each worker will be assigned an event loop round-robin. If the number of workers is larger than the number of event loops, some event loops will have multiple workers.