Merge pull request #5 from Mordil/rev-2

Rev 2

Author: Mordil

Package.swift

@@ -1,20 +1,19 @@
-// swift-tools-version:4.2
+// swift-tools-version:5.0
 
 import PackageDescription
 
 let package = Package(
-    name: "Redis",
+    name: "nio-redis",
     products: [
         .library(name: "NIORedis", targets: ["NIORedis"]),
-        .library(name: "Redis", targets: ["Redis"])
+        .library(name: "DispatchRedis", targets: ["DispatchRedis"])
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-nio.git", .branch("master"))
     ],
     targets: [
         .target(name: "NIORedis", dependencies: ["NIO"]),
-        .target(name: "Redis", dependencies: ["NIORedis"]),
-        .testTarget(name: "NIORedisTests", dependencies: ["NIORedis", "NIO"]),
-        //.testTarget(name: "RedisTests", dependencies: ["Redis"])
+        .target(name: "DispatchRedis", dependencies: ["NIORedis"]),
+        .testTarget(name: "NIORedisTests", dependencies: ["NIORedis", "NIO"])
     ]
 )

README.md

@@ -1,161 +1,56 @@
-# NIORedis: Client for Redis server built on NIO
-This package includes two modules: `NIORedis` and `Redis`, which provide clients that handle connection to, authorizing, and 
-executing commands against a Redis server.
+# NIORedis: A Redis Driver built on SwiftNIO
 
-`NIORedis` provides channel handlers for encoding / decoding between Swift native types and [Redis' Serialization Protocol (RESP)](https://redis.io/topics/protocol).
-
-`Redis` is an abstraction layer that wraps `NIORedis` to be callback based with `DispatchQueue`.
-
-# Motivation
-Implementations of Redis connections have decayed as newer capabilities of the Swift STD Library, SwiftNIO, and the Swift language itself have developed.
-
-As part of the iniative of trying to push the ecosystem to be centered around SwiftNIO, a framework-agnostic driver on Redis can provide an
-easier time for feature development on Redis.
-
-# Proposed Solution
-A barebones implementation is available at [mordil/nio-redis](https://github.com/mordil/nio-redis).
-
-The following are already implemented, with unit tests:
-
-- [Connection and Authorization](https://github.com/Mordil/nio-redis/blob/master/Sources/NIORedis/NIORedis.swift#L35)
-- [Raw commands](https://github.com/Mordil/nio-redis/blob/master/Sources/NIORedis/NIORedisConnection.swift#L33)
-- [Convienence methods for:](https://github.com/Mordil/nio-redis/blob/master/Sources/NIORedis/Commands/BasicCommands.swift#L4)
-  - GET
-  - SET
-  - AUTH
-  - DEL
-  - SELECT
-  - EXPIRE
-- NIO-wrapped abstractions for
-  - [Client](https://github.com/Mordil/nio-redis/blob/master/Sources/Redis/Redis.swift)
-  - [Connection](https://github.com/Mordil/nio-redis/blob/master/Sources/Redis/RedisConnection.swift)
-  - [Pipelines](https://github.com/Mordil/nio-redis/blob/master/Sources/Redis/RedisPipeline.swift)
-  - GET command
-- Unit tests for
-  - Response decoding to native Swift
-  - Message encoding to RESP
-  - Connections
-  - implemented commands
-  - pipelines
-
-This package is a re-implementation of [vapor/redis](https://github.com/vapor/redis) stripped down to only build on SwiftNIO to be framework agnostic.
-
-Much of this was inspired by the [NIOPostgres pitch](https://forums.swift.org/t/pitch-swiftnio-based-postgresql-client/18020).
-
-# Details Solution
+* Pitch discussion: [Swift Server Forums](https://forums.swift.org/t/swiftnio-redis-client/19325/13)
 
 > **NOTE: This this is written against SwiftNIO 2.0, and as such requires Swift 5.0!**
 
-This is to take advantage of the [`Result`](https://github.com/apple/swift-evolution/blob/master/proposals/0235-add-result.md) type in the `Redis` module,
+This is to take advantage of the [`Result`](https://github.com/apple/swift-evolution/blob/master/proposals/0235-add-result.md) type in the `DispatchRedis` module,
 and to stay ahead of development of the next version of SwiftNIO.
 
-## NIORedis
-Most use of this library will be focused on a `NIORedisConnection` type that works explicitly in a SwiftNIO `EventLoop` context - with
-return values all being `EventLoopFuture`.
-
 ```swift
 import NIORedis
 
 let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-let redis = NIORedis(executionModel: .eventLoopGroup(elg))
+let driver = RedisDriver(ownershipModel: .external(elg))
 
 // connections
 
-// passing a value to `password` will automatically authenticate with Redis before resolving the connection
+// passing a value to 'password' will automatically authenticate with Redis before resolving the connection
 let connection = try redis.makeConnection(
     hostname: "localhost", // this is the default
     port: 6379, // this is the default
-    password: "MY_PASS" // default is `nil`
+    password: "MY_PASS" // default is 'nil'
 ).wait()
-print(connection) // NIORedisConnection
 
-// convienence methods for commands
+// convenience methods for commands
 
-let result = try connection.set("my_key", to: "some value")
-    .then {
-        return connection.get("my_key")
-    }.wait()
+let result = try conneciton.set("my_key", to: "some value")
+    .then { return connection.get("my_key")}
+    .wait()
 print(result) // Optional("some value")
 
 // raw commands
 
-let keyCount = try connection.command("DEL", [RedisData(bulk: "my_key")])
-    .thenThrowing { res in
+let keyCount = try connection.command("DEL", [RESPValue(bulk: "my_key")])
+    .thenThrowing { response in
         guard case let .integer(count) else {
-            // throw Error
+            // throw error
         }
         return count
-    }.wait()
+    }
+    .wait()
 print(keyCount) // 1
 
-// cleanup 
+// cleanup
 
 connection.close()
-try redis.terminate()
-try elg.syncShutdownGracefully()
+    .thenThrowing { try redis.terminate() }
+    .whenSuccess { try elg.syncShutdownGracefully() }
 ```
 
-### RedisData & RedisDataConvertible
+### RESPValue & RESPValueConvertible
 This is a 1:1 mapping enum of the `RESP` types: `Simple String`, `Bulk String`, `Array`, `Integer` and `Error`.
 
-Conforming to `RedisDataConvertible` allows Swift types to more easily convert between `RedisData` and native types.
-
-`Array`, `Data`, `Float`, `Double`, `FixedWidthInteger`, `String`, and of course `RedisData` all conform in this package.
-
-A `ByteToMessageDecoder` and `MessageToByteEncoder` are used for the conversion process on connections.
-
-### NIORedisConnection
-This class uses a `ChannelInboundHandler` that handles the actual process of sending and receiving commands.
-
-While it does handle a queue of messages, so as to not be blocking, pipelining is implemented with `NIORedisPipeline`.
-
-### NIORedisPipeline
-A `NIORedisPipeline` is a quick abstraction that buffers an array of complete messages as `RedisData`, and executing them in sequence after a
-user has invoked `execute()`.
-
-It returns an `EventLoopFuture<[RedisData]>` with the results of all commands executed - unless one errors.
+Conforming to `RESPValueConvertible` allows Swift types to more easily convert between `RESPValue` and native types.
 
-## Redis
-
-To support contexts where someone either doesn't want to work in a SwiftNIO context, the `Redis` module provides a callback-based interface
-that wraps all of `NIORedis`.
-
-A `Redis` instance manages a `NIORedis` object under the hood, with `RedisConnection` doing the same for `NIORedisConnection`.
-
-```swift
-import Redis
-
-let redis = Redis(threadCount: 1) // default is 1
-
-// connections
-
-// passing a value to `password` will automatically authenticate with Redis before resolving the connection
-redis.makeConnection(
-    hostname: "localhost", // this is the default
-    port: 6379, // this is the default
-    password: "MY_PASS", // default is `nil`
-    queue: DispatchQueue(label: "com.MyPackage.redis") // default is `.main`
-) { result in
-    switch result {
-    case .success(let conn):
-        showCommands(on: conn)
-    case .failure(let error):
-        fatalError("Could not create RedisConnection!")
-    }
-}
-
-// convienence methods for commands
-
-func showCommands(on conn: RedisConnection) {
-    conn.get("my_key") { result in
-        switch result {
-        case .success(let value):
-            // use value, which is String?
-        case .failure(let error):
-            // do something on error
-        }
-    }
-}
-
-// cleanup is handled by deinit blocks
-```
+`Array`, `Data`, `Float`, `Double`, `FixedWidthInteger`, `String`, and of course `RESPValue` all conform in this package.

Sources/Redis/Redis.swift renamed to Sources/DispatchRedis/Redis.swift

@@ -4,12 +4,12 @@ import NIORedis
 
 /// A factory that handles all necessary details for creating `RedisConnection` instances.
 public final class Redis {
-    private let driver: NIORedis
+    private let driver: RedisDriver
 
     deinit { try? driver.terminate() }
 
     public init(threadCount: Int = 1) {
-        self.driver = NIORedis(executionModel: .spawnThreads(threadCount))
+        self.driver = RedisDriver(ownershipModel: .internal(threadCount: threadCount))
     }
 
     public func makeConnection(

Sources/Redis/RedisConnection.swift renamed to Sources/DispatchRedis/RedisConnection.swift

@@ -2,20 +2,20 @@ import Foundation
 import NIORedis
 
 public final class RedisConnection {
-    let _driverConnection: NIORedisConnection
+    let _driverConnection: NIORedis.RedisConnection
 
     private let queue: DispatchQueue
 
     deinit { _driverConnection.close() }
 
-    init(driver: NIORedisConnection, callbackQueue: DispatchQueue) {
+    init(driver: NIORedis.RedisConnection, callbackQueue: DispatchQueue) {
         self._driverConnection = driver
         self.queue = callbackQueue
     }
 
     /// Creates a `RedisPipeline` for executing a batch of commands.
     public func makePipeline(callbackQueue: DispatchQueue? = nil) -> RedisPipeline {
-        return .init(using: self, callbackQueue: callbackQueue ?? queue)
+        return .init(connection: self, callbackQueue: callbackQueue ?? queue)
     }
 
     public func get(

Sources/Redis/RedisPipeline.swift renamed to Sources/DispatchRedis/RedisPipeline.swift

@@ -14,15 +14,15 @@ import NIORedis
 /// - Important: The larger the pipeline queue, the more memory both the Redis driver and Redis server will use.
 /// See https://redis.io/topics/pipelining#redis-pipelining
 public final class RedisPipeline {
-    private let _driverPipeline: NIORedisPipeline
+    private let _driverPipeline: NIORedis.RedisPipeline
     private let queue: DispatchQueue
 
     /// Creates a new pipeline queue using the provided `RedisConnection`, executing callbacks on the provided `DispatchQueue`.
     /// - Parameters:
     ///     - using: The connection to execute the commands on.
     ///     - callbackQueue: The queue to execute all callbacks on.
-    public init(using connection: RedisConnection, callbackQueue: DispatchQueue) {
-        self._driverPipeline = NIORedisPipeline(using: connection._driverConnection)
+    public init(connection: RedisConnection, callbackQueue: DispatchQueue) {
+        self._driverPipeline = NIORedis.RedisPipeline(channel: connection._driverConnection.channel)
         self.queue = callbackQueue
     }
 
@@ -32,15 +32,15 @@ public final class RedisPipeline {
     ///     - arguments: The arguments, if any, to send with the command.
     /// - Returns: A self-reference to this `RedisPipeline` instance for chaining commands.
     @discardableResult
-    public func enqueue(command: String, arguments: [RedisDataConvertible] = []) throws -> RedisPipeline {
+    public func enqueue(command: String, arguments: [RESPConvertible] = []) throws -> RedisPipeline {
         try _driverPipeline.enqueue(command: command, arguments: arguments)
         return self
     }
 
     /// Flushes the queue, sending all of the commands to Redis in the same order as they were enqueued.
     /// - Important: If any of the commands fail, the remaining commands will not execute and the callback will receive a failure.
     /// - Parameter callback: The callback to receive the results of the pipeline of commands, or an error if thrown.
-    public func execute(_ callback: @escaping (Result<[RedisData], Error>) -> Void) {
+    public func execute(_ callback: @escaping (Result<[RESPValue], Error>) -> Void) {
         _driverPipeline.execute()
             .map { results in
                 self.queue.async { callback(.success(results)) }