beta.2 (#49)

* beta.2

* rm print + fix warning

.github/workflows/test.yml

@@ -8,15 +8,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v1
-      - run: swift test --enable-test-discovery
+      - run: swift test --enable-test-discovery --sanitize=thread
   bionic:
-    container:
-      image: vapor/swift:5.1-bionic
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1
-      - run: swift test --enable-test-discovery
-  thread:
     container:
       image: vapor/swift:5.1-bionic
     runs-on: ubuntu-latest

Package.swift

@@ -10,7 +10,7 @@ let package = Package(
         .library(name: "Jobs", targets: ["Jobs"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/vapor/vapor.git", .branch("master"))
+        .package(url: "https://github.com/vapor/vapor.git", from: "4.0.0-beta.2")
     ],
     targets: [
         .target(name: "Jobs", dependencies: ["Vapor"]),

Sources/Jobs/Application+Jobs.swift

@@ -0,0 +1,110 @@
+import Foundation
+import Vapor
+import NIO
+
+extension Application {
+    public var jobs: Jobs {
+        .init(application: self)
+    }
+
+    public struct Jobs {
+        public struct Provider {
+            let run: (Application) -> ()
+
+            public init(_ run: @escaping (Application) -> ()) {
+                self.run = run
+            }
+        }
+
+        final class Storage {
+            public var configuration: JobsConfiguration
+            let command: JobsCommand
+            var driver: JobsDriver?
+
+            public init(_ application: Application) {
+                self.configuration = .init(logger: application.logger)
+                self.command = .init(application: application)
+                application.commands.use(self.command, as: "jobs")
+            }
+
+        }
+
+        struct Key: StorageKey {
+            typealias Value = Storage
+        }
+
+        struct Lifecycle: LifecycleHandler {
+            func shutdown(_ application: Application) {
+                application.jobs.storage.command.shutdown()
+                if let driver = application.jobs.storage.driver {
+                    driver.shutdown()
+                }
+            }
+        }
+
+        public var configuration: JobsConfiguration {
+            get { self.storage.configuration }
+            nonmutating set { self.storage.configuration = newValue }
+        }
+
+        public var queue: JobsQueue {
+            self.queue(.default)
+        }
+
+        public var driver: JobsDriver {
+            guard let driver = self.storage.driver else {
+                fatalError("No Jobs driver configured. Configure with app.jobs.use(...)")
+            }
+            return driver
+        }
+
+        var storage: Storage {
+            if self.application.storage[Key.self] == nil {
+                self.initialize()
+            }
+            return self.application.storage[Key.self]!
+        }
+
+        let application: Application
+
+        public func queue(
+            _ name: JobsQueueName,
+            logger: Logger? = nil,
+            on eventLoop: EventLoop? = nil
+        ) -> JobsQueue {
+            return self.driver.makeQueue(
+                with: .init(
+                    queueName: name,
+                    configuration: self.configuration,
+                    logger: logger ?? self.application.logger,
+                    on: eventLoop ?? self.application.eventLoopGroup.next()
+                )
+            )
+        }
+
+        public func add<J>(_ job: J) where J: Job {
+            self.configuration.add(job)
+        }
+
+        public func use(_ provider: Provider) {
+            provider.run(self.application)
+        }
+
+        public func use(custom driver: JobsDriver) {
+            self.storage.driver = driver
+        }
+
+        public func schedule<J>(_ job: J) -> ScheduleBuilder
+            where J: ScheduledJob
+        {
+            let builder = ScheduleBuilder()
+            _ = self.storage.configuration.schedule(job, builder: builder)
+            return builder
+        }
+
+        func initialize() {
+            self.application.lifecycle.use(Lifecycle())
+            self.application.storage[Key.self] = .init(application)
+        }
+    }
+}

Sources/Jobs/JobsCommand.swift

@@ -1,5 +1,5 @@
 import Vapor
-import class NIOConcurrencyHelpers.Atomic
+import class NIOConcurrencyHelpers.NIOAtomic
 import class NIO.RepeatedTask
 
 /// The command to start the Queue job
@@ -31,7 +31,7 @@ public final class JobsCommand: Command {
     private var didShutdown: Bool
 
 
-    let isShuttingDown: Atomic<Bool>
+    let isShuttingDown: NIOAtomic<Bool>
 
     private var eventLoopGroup: EventLoopGroup {
         self.application.eventLoopGroup
@@ -42,7 +42,7 @@ public final class JobsCommand: Command {
         self.application = application
         self.jobTasks = []
         self.scheduledTasks = [:]
-        self.isShuttingDown = .init(value: false)
+        self.isShuttingDown = .makeAtomic(value: false)
         self.signalSources = []
         self.didShutdown = false
         self.lock = .init()

Sources/Jobs/Request+Jobs.swift

@@ -0,0 +1,17 @@
+import Foundation
+import Vapor
+import NIO
+
+extension Request {
+    public var jobs: JobsQueue {
+        self.jobs(.default)
+    }
+
+    public func jobs(_ queue: JobsQueueName) -> JobsQueue {
+        self.application.jobs.queue(
+            queue,
+            logger: self.logger,
+            on: self.eventLoop
+        )
+    }
+}

Tests/JobsTests/JobsTests.swift

@@ -7,7 +7,6 @@ final class JobsTests: XCTestCase {
     func testVaporIntegration() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
-        app.use(Jobs.self)
         app.jobs.use(custom: TestDriver())
 
         let promise = app.eventLoopGroup.next().makePromise(of: String.self)
@@ -40,8 +39,6 @@ final class JobsTests: XCTestCase {
         let app = Application(.testing)
         defer { app.shutdown() }
 
-        app.use(Jobs.self)
-
         // yearly
         app.jobs.schedule(Cleanup())
             .yearly()