Swift Package IndexBuild Information
Successful build of RediStack, reference 1.6.2 (622ce4), with Swift 6.1 for Linux on 27 Apr 2025 20:08:48 UTC.
Swift 6 data race errors: 7
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4609320-2":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1Build Log
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:185:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
183 |
184 | self.loop.execute {
185 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
186 |
187 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:69: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:420:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
418 | // a "no-op" unsub, so we need to return this connection
419 | guard
420 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:439:30: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
437 | // Establish event loop context then jump to the in-loop version.
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
440 | return self.forwardOperationToConnection(
441 | operation,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:18: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:440:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
441 | operation,
442 | preferredConnection: preferredConnection,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:441:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
441 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
442 | preferredConnection: preferredConnection,
443 | context: context
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:442:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
440 | return self.forwardOperationToConnection(
441 | operation,
442 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
443 | context: context
444 | )
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[728/731] Compiling RediStack ConnectionPool.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:119:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
117 | extension RedisSetCommandCondition {
118 | /// No condition is required to be met in order to set the key's value.
119 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 |
121 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:124:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
122 | ///
123 | /// Redis documentation refers to this as the option "XX".
124 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
125 |
126 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:129:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
127 | ///
128 | /// Redis documentation refers to this as the option "NX".
129 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | }
131 |
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:166:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
133 | ///
134 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
135 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
136 | private enum Expiration: Hashable {
137 | case keepExisting
:
164 | /// Redis documentation refers to this as "KEEPTTL".
165 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
166 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
167 |
168 | /// Expire the key after the given number of seconds.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:52:59: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
50 | /// - Returns: The values stored at the keys provided, matching the same order.
51 | public func mget(_ keys: [RedisKey]) -> EventLoopFuture<[RESPValue]> {
52 | guard keys.count > 0 else { return self.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
53 |
54 | let args = keys.map(RESPValue.init)
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:140:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
138 | } else {
139 | self.loop.execute {
140 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
141 | }
142 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:153:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
151 | } else {
152 | self.loop.execute {
153 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
154 | }
155 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:162:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
160 | return self._leaseConnection(deadline, logger: logger)
161 | } else {
162 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
163 | return self._leaseConnection(deadline, logger: logger)
164 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:163:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
161 | } else {
162 | return self.loop.flatSubmit {
163 | return self._leaseConnection(deadline, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
164 | }
165 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:205:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
203 |
204 | self.loop.scheduleTask(in: delay) {
205 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:207:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
205 | self.connectionFactory(self.loop)
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
208 |
209 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:463:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
461 | private func closeConnectionForShutdown(_ connection: RedisConnection) {
462 | connection.close().whenComplete { _ in
463 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
464 |
465 | switch self.state {
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:477:55: warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
475 | // The state must not change if we are closing a connection, while we are
476 | // closing the pool.
477 | preconditionFailure("Invalid state: \(self.state)")
| `- warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
478 | }
479 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:527:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
523 | }
524 |
525 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
526 | assert(self.timeoutTask == nil)
527 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
528 | }
529 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:532:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
530 | func succeed(_ connection: RedisConnection) {
531 | self.timeoutTask?.cancel()
532 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
533 | }
534 |
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:100:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
98 | public func activate(logger: Logger? = nil) {
99 | self.loop.execute {
100 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
101 | }
102 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:113:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
111 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
112 | self.loop.execute {
113 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
114 |
115 | self.pubsubConnection = nil
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:192:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
190 |
191 | for request in unbufferedRequests {
192 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
193 | }
194 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:185:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
183 |
184 | self.loop.execute {
185 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
186 |
187 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:69: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:420:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
418 | // a "no-op" unsub, so we need to return this connection
419 | guard
420 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:439:30: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
437 | // Establish event loop context then jump to the in-loop version.
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
440 | return self.forwardOperationToConnection(
441 | operation,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:18: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:440:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
441 | operation,
442 | preferredConnection: preferredConnection,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:441:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
441 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
442 | preferredConnection: preferredConnection,
443 | context: context
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:442:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
440 | return self.forwardOperationToConnection(
441 | operation,
442 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
443 | context: context
444 | )
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[729/731] Compiling RediStack RedisConnectionPool+Configuration.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:119:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
117 | extension RedisSetCommandCondition {
118 | /// No condition is required to be met in order to set the key's value.
119 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 |
121 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:124:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
122 | ///
123 | /// Redis documentation refers to this as the option "XX".
124 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
125 |
126 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:129:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
127 | ///
128 | /// Redis documentation refers to this as the option "NX".
129 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | }
131 |
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:166:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
133 | ///
134 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
135 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
136 | private enum Expiration: Hashable {
137 | case keepExisting
:
164 | /// Redis documentation refers to this as "KEEPTTL".
165 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
166 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
167 |
168 | /// Expire the key after the given number of seconds.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:52:59: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
50 | /// - Returns: The values stored at the keys provided, matching the same order.
51 | public func mget(_ keys: [RedisKey]) -> EventLoopFuture<[RESPValue]> {
52 | guard keys.count > 0 else { return self.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
53 |
54 | let args = keys.map(RESPValue.init)
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:140:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
138 | } else {
139 | self.loop.execute {
140 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
141 | }
142 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:153:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
151 | } else {
152 | self.loop.execute {
153 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
154 | }
155 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:162:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
160 | return self._leaseConnection(deadline, logger: logger)
161 | } else {
162 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
163 | return self._leaseConnection(deadline, logger: logger)
164 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:163:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
161 | } else {
162 | return self.loop.flatSubmit {
163 | return self._leaseConnection(deadline, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
164 | }
165 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:205:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
203 |
204 | self.loop.scheduleTask(in: delay) {
205 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:207:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
205 | self.connectionFactory(self.loop)
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
208 |
209 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:463:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
461 | private func closeConnectionForShutdown(_ connection: RedisConnection) {
462 | connection.close().whenComplete { _ in
463 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
464 |
465 | switch self.state {
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:477:55: warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
475 | // The state must not change if we are closing a connection, while we are
476 | // closing the pool.
477 | preconditionFailure("Invalid state: \(self.state)")
| `- warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
478 | }
479 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:527:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
523 | }
524 |
525 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
526 | assert(self.timeoutTask == nil)
527 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
528 | }
529 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:532:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
530 | func succeed(_ connection: RedisConnection) {
531 | self.timeoutTask?.cancel()
532 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
533 | }
534 |
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:100:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
98 | public func activate(logger: Logger? = nil) {
99 | self.loop.execute {
100 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
101 | }
102 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:113:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
111 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
112 | self.loop.execute {
113 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
114 |
115 | self.pubsubConnection = nil
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:192:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
190 |
191 | for request in unbufferedRequests {
192 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
193 | }
194 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:185:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
183 |
184 | self.loop.execute {
185 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
186 |
187 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:69: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:420:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
418 | // a "no-op" unsub, so we need to return this connection
419 | guard
420 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:439:30: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
437 | // Establish event loop context then jump to the in-loop version.
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
440 | return self.forwardOperationToConnection(
441 | operation,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:18: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:440:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
441 | operation,
442 | preferredConnection: preferredConnection,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:441:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
441 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
442 | preferredConnection: preferredConnection,
443 | context: context
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:442:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
440 | return self.forwardOperationToConnection(
441 | operation,
442 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
443 | context: context
444 | )
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[730/731] Compiling RediStack RedisConnectionPool.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:119:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
117 | extension RedisSetCommandCondition {
118 | /// No condition is required to be met in order to set the key's value.
119 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 |
121 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:124:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
122 | ///
123 | /// Redis documentation refers to this as the option "XX".
124 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
125 |
126 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:129:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
127 | ///
128 | /// Redis documentation refers to this as the option "NX".
129 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | }
131 |
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:166:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
133 | ///
134 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
135 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
136 | private enum Expiration: Hashable {
137 | case keepExisting
:
164 | /// Redis documentation refers to this as "KEEPTTL".
165 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
166 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
167 |
168 | /// Expire the key after the given number of seconds.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:52:59: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
50 | /// - Returns: The values stored at the keys provided, matching the same order.
51 | public func mget(_ keys: [RedisKey]) -> EventLoopFuture<[RESPValue]> {
52 | guard keys.count > 0 else { return self.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
53 |
54 | let args = keys.map(RESPValue.init)
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:140:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
138 | } else {
139 | self.loop.execute {
140 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
141 | }
142 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:153:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
151 | } else {
152 | self.loop.execute {
153 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
154 | }
155 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:162:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
160 | return self._leaseConnection(deadline, logger: logger)
161 | } else {
162 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
163 | return self._leaseConnection(deadline, logger: logger)
164 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:163:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
161 | } else {
162 | return self.loop.flatSubmit {
163 | return self._leaseConnection(deadline, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
164 | }
165 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:205:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
203 |
204 | self.loop.scheduleTask(in: delay) {
205 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:207:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
205 | self.connectionFactory(self.loop)
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
208 |
209 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:463:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
461 | private func closeConnectionForShutdown(_ connection: RedisConnection) {
462 | connection.close().whenComplete { _ in
463 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
464 |
465 | switch self.state {
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:477:55: warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
475 | // The state must not change if we are closing a connection, while we are
476 | // closing the pool.
477 | preconditionFailure("Invalid state: \(self.state)")
| `- warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
478 | }
479 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:527:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
523 | }
524 |
525 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
526 | assert(self.timeoutTask == nil)
527 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
528 | }
529 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:532:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
530 | func succeed(_ connection: RedisConnection) {
531 | self.timeoutTask?.cancel()
532 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
533 | }
534 |
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:100:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
98 | public func activate(logger: Logger? = nil) {
99 | self.loop.execute {
100 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
101 | }
102 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:113:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
111 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
112 | self.loop.execute {
113 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
114 |
115 | self.pubsubConnection = nil
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:192:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
190 |
191 | for request in unbufferedRequests {
192 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
193 | }
194 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:185:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
183 |
184 | self.loop.execute {
185 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
186 |
187 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:69: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:420:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
418 | // a "no-op" unsub, so we need to return this connection
419 | guard
420 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:439:30: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
437 | // Establish event loop context then jump to the in-loop version.
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
440 | return self.forwardOperationToConnection(
441 | operation,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:18: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:440:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
441 | operation,
442 | preferredConnection: preferredConnection,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:441:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
441 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
442 | preferredConnection: preferredConnection,
443 | context: context
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:442:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
440 | return self.forwardOperationToConnection(
441 | operation,
442 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
443 | context: context
444 | )
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[731/731] Compiling RediStack RedisConnectionPoolError.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:119:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
117 | extension RedisSetCommandCondition {
118 | /// No condition is required to be met in order to set the key's value.
119 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 |
121 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:124:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
122 | ///
123 | /// Redis documentation refers to this as the option "XX".
124 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
125 |
126 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:129:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
97 | ///
98 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
99 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
100 | private enum Condition: String, Hashable {
101 | case keyExists = "XX"
:
127 | ///
128 | /// Redis documentation refers to this as the option "NX".
129 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | }
131 |
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:166:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
133 | ///
134 | /// See [https://redis.io/commands/set](https://redis.io/commands/set)
135 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
136 | private enum Expiration: Hashable {
137 | case keepExisting
:
164 | /// Redis documentation refers to this as "KEEPTTL".
165 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
166 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
167 |
168 | /// Expire the key after the given number of seconds.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:52:59: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
50 | /// - Returns: The values stored at the keys provided, matching the same order.
51 | public func mget(_ keys: [RedisKey]) -> EventLoopFuture<[RESPValue]> {
52 | guard keys.count > 0 else { return self.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
53 |
54 | let args = keys.map(RESPValue.init)
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:140:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
138 | } else {
139 | self.loop.execute {
140 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
141 | }
142 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:153:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
151 | } else {
152 | self.loop.execute {
153 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
154 | }
155 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:162:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
160 | return self._leaseConnection(deadline, logger: logger)
161 | } else {
162 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
163 | return self._leaseConnection(deadline, logger: logger)
164 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:163:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
161 | } else {
162 | return self.loop.flatSubmit {
163 | return self._leaseConnection(deadline, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
164 | }
165 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:173:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
171 | } else {
172 | return self.loop.execute {
173 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
174 | }
175 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:205:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
203 |
204 | self.loop.scheduleTask(in: delay) {
205 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:207:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
205 | self.connectionFactory(self.loop)
206 | .whenComplete { result in
207 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
208 |
209 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:242:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | // Great, we want this. We'll be "returning" it to the pool. First,
241 | // attach the close callback to it.
242 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | self._returnConnection(connection, logger: logger)
244 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:463:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
461 | private func closeConnectionForShutdown(_ connection: RedisConnection) {
462 | connection.close().whenComplete { _ in
463 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
464 |
465 | switch self.state {
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:477:55: warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
:
475 | // The state must not change if we are closing a connection, while we are
476 | // closing the pool.
477 | preconditionFailure("Invalid state: \(self.state)")
| `- warning: implicit capture of 'self' requires that 'ConnectionPool' conforms to 'Sendable'; this is an error in the Swift 6 language mode
478 | }
479 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:527:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
523 | }
524 |
525 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
526 | assert(self.timeoutTask == nil)
527 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
528 | }
529 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:532:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
530 | func succeed(_ connection: RedisConnection) {
531 | self.timeoutTask?.cancel()
532 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
533 | }
534 |
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:100:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
98 | public func activate(logger: Logger? = nil) {
99 | self.loop.execute {
100 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
101 | }
102 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:113:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
111 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
112 | self.loop.execute {
113 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
114 |
115 | self.pubsubConnection = nil
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:161:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
159 |
160 | return operation(connection)
161 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
162 | },
163 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:192:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
190 |
191 | for request in unbufferedRequests {
192 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
193 | }
194 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:185:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
183 |
184 | self.loop.execute {
185 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
186 |
187 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:242:69: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
240 | connection.allowSubscriptions = false
241 | connection.channel.closeFuture.whenComplete { _ in
242 | self.configuration.onUnexpectedConnectionClose?(connection)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
243 | }
244 | return connection
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:316:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
314 | return connection
315 | .send(command: command, with: arguments, logger: context)
316 | .always { _ in returnConnection(connection, context) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
317 | },
318 | preferredConnection: nil,
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:420:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
418 | // a "no-op" unsub, so we need to return this connection
419 | guard
420 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:423:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
421 | self.leasedConnectionCount > 0
422 | else { return }
423 | returnConnection(connection, context)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
424 | }
425 | },
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:439:30: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
437 | // Establish event loop context then jump to the in-loop version.
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
440 | return self.forwardOperationToConnection(
441 | operation,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:18: warning: type 'T' does not conform to the 'Sendable' protocol
430 |
431 | @usableFromInline
432 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
433 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
434 | preferredConnection: RedisConnection?,
:
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:440:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
27 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
28 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
29 | public final class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
30 | /// A unique identifer to represent this connection.
31 | public let id = UUID()
:
438 | guard self.loop.inEventLoop else {
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
441 | operation,
442 | preferredConnection: preferredConnection,
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:441:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
439 | return self.loop.flatSubmit {
440 | return self.forwardOperationToConnection(
441 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
442 | preferredConnection: preferredConnection,
443 | context: context
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:442:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
440 | return self.forwardOperationToConnection(
441 | operation,
442 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
443 | context: context
444 | )
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/RedisConnectionPool.swift:462:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
460 | logger: logger
461 | )
462 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
463 | }
464 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[733/741] Compiling RediStackTestUtils _Deprecations.swift
[734/741] Compiling RediStackTestUtils RedisIntegrationTestCase.swift
/host/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:69:37: warning: capture of 'self' with non-sendable type 'RedisIntegrationTestCase' in a '@Sendable' closure
21 | ///
22 | /// See `RedisConnection.make(configuration:boundEventLoop:)` to understand how connections are made.
23 | open class RedisIntegrationTestCase: XCTestCase {
| `- note: class 'RedisIntegrationTestCase' does not conform to the 'Sendable' protocol
24 | /// An overridable value of the Redis instance's hostname to connect to for the test suite(s).
25 | ///
:
67 | if self.connection.isConnected {
68 | _ = try self.connection.send(command: "FLUSHALL")
69 | .flatMap { _ in self.connection.close() }
| `- warning: capture of 'self' with non-sendable type 'RedisIntegrationTestCase' in a '@Sendable' closure
70 | .wait()
71 | }
/host/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:91:11: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
89 | ),
90 | boundEventLoop: eventLoopGroup.next()
91 | ).wait()
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
92 | }
93 | }
/host/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:86:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
84 | ///
85 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
86 | public final class RedisConnection: RedisClient, RedisClientWithUserContext {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
87 | /// A unique identifer to represent this connection.
88 | public let id = UUID()
/host/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
14 |
15 | import NIOCore
16 | import RediStack
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
17 | import NIOPosix
18 | import XCTest
[735/741] Compiling RediStackTestUtils RedisConnectionPoolIntegrationTestCase.swift
/host/spi-builder-workspace/Sources/RediStackTestUtils/RedisConnectionPoolIntegrationTestCase.swift:67:57: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
65 | open override func tearDown() {
66 | do {
67 | _ = try self.pool.send(command: "FLUSHALL").wait()
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
68 | } catch let err as RedisConnectionPoolError where err == .poolClosed {
69 | // Ok, this is fine.
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStackTestUtils/RedisConnectionPoolIntegrationTestCase.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
14 |
15 | import NIOCore
16 | import RediStack
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
17 | import XCTest
18 | import NIOPosix
[736/741] Compiling RediStackTestUtils General.swift
[737/741] Compiling RediStackTestUtils RediStack.swift
[738/741] Compiling RedisTypes RedisSet.swift
/host/spi-builder-workspace/Sources/RedisTypes/RedisSet.swift:199:62: warning: type 'Element' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
57 | ///
58 | /// See [https://redis.io/topics/data-types-intro#sets](https://redis.io/topics/data-types-intro#sets)
59 | public struct RedisSet<Element> where Element: RESPValueConvertible {
| `- note: consider making generic parameter 'Element' conform to the 'Sendable' protocol
60 | /// The key in Redis that this instance is a reference to.
61 | public var identifier: RedisKey { return self.id }
:
197 | public func popRandomElements(max count: Int) -> EventLoopFuture<[Element]> {
198 | guard count >= 0 else { return self.client.eventLoop.makeFailedFuture(RedisError.indexOutOfRange) }
199 | guard count >= 1 else { return self.client.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'Element' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
200 | return self.client.spop(from: self.id, max: count)
201 | .map { return $0.compactMap(Element.init) }
[739/741] Emitting module RedisTypes
[740/741] Emitting module RediStackTestUtils
[741/741] Compiling RediStackTestUtils EmbeddedMockRedisServer.swift
/host/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:62:34: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
60 | // We always allow this.
61 | let response = RESPValue.simpleString("OK".byteBuffer)
62 | data.responsePromise.succeed(response)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
63 |
64 | default:
/host/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/host/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
13 | //===----------------------------------------------------------------------===//
14 |
15 | import RediStack
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
16 | import XCTest
17 | import NIOCore
/host/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:73:13: warning: capture of 'self' with non-sendable type 'EmbeddedMockRedisServer' in a '@Sendable' closure
26 | /// This is not really a Redis server: it's just something that lets us stub out the connection management in order to let
27 | /// us test the connection pool.
28 | internal final class EmbeddedMockRedisServer {
| `- note: class 'EmbeddedMockRedisServer' does not conform to the 'Sendable' protocol
29 | var channels: ArraySlice<EmbeddedChannel> = []
30 | var loop: EmbeddedEventLoop = EmbeddedEventLoop()
:
71 | let channel = EmbeddedChannel(handler: GracefulShutdownToCloseHandler(), loop: self.loop)
72 | channel.closeFuture.whenComplete { _ in
73 | self.channels.removeAll(where: { $0 === channel })
| `- warning: capture of 'self' with non-sendable type 'EmbeddedMockRedisServer' in a '@Sendable' closure
74 | }
75 |
Build complete! (105.22s)
Build complete.
{
"dependencies" : [
{
"identity" : "swift-atomics",
"requirement" : {
"range" : [
{
"lower_bound" : "1.1.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-atomics.git"
},
{
"identity" : "swift-log",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-log.git"
},
{
"identity" : "swift-metrics",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-metrics.git"
},
{
"identity" : "swift-nio",
"requirement" : {
"range" : [
{
"lower_bound" : "2.43.0",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-nio.git"
},
{
"identity" : "swift-nio-ssl",
"requirement" : {
"range" : [
{
"lower_bound" : "2.23.1",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-nio-ssl.git"
}
],
"manifest_display_name" : "RediStack",
"name" : "RediStack",
"path" : "/host/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "RediStack",
"targets" : [
"RediStack"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "RediStackTestUtils",
"targets" : [
"RediStackTestUtils"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "RedisTypes",
"targets" : [
"RedisTypes"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "RedisTypesTests",
"module_type" : "SwiftTarget",
"name" : "RedisTypesTests",
"path" : "Tests/RedisTypesTests",
"product_dependencies" : [
"NIO"
],
"sources" : [
"RedisSetTests.swift",
"RedisTypesIntegrationTestCase.swift"
],
"target_dependencies" : [
"RediStack",
"RedisTypes",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RedisTypes",
"module_type" : "SwiftTarget",
"name" : "RedisTypes",
"path" : "Sources/RedisTypes",
"product_memberships" : [
"RedisTypes"
],
"sources" : [
"RedisSet.swift"
],
"target_dependencies" : [
"RediStack"
],
"type" : "library"
},
{
"c99name" : "RediStackTests",
"module_type" : "SwiftTarget",
"name" : "RediStackTests",
"path" : "Tests/RediStackTests",
"product_dependencies" : [
"Atomics",
"NIO",
"NIOTestUtils"
],
"sources" : [
"ChannelHandlers/RedisByteDecoderTests.swift",
"ChannelHandlers/RedisCommandHandlerTests.swift",
"ChannelHandlers/RedisMessageEncoderTests.swift",
"Cluster/RedisClusterNodeDescriptionProtocolTests.swift",
"ConfigurationTests.swift",
"ConnectionPoolTests.swift",
"Helpers/MockNodeDescription.swift",
"Helpers/RedisErrorTests.swift",
"RESPTranslatorTests.swift",
"RESPValueTests.swift",
"RedisCommandEncoderTests.swift",
"RedisConnection+ConfigurationTests.swift",
"RedisConnectionTests.swift",
"RedisHashSlotTests.swift",
"RedisKeyLifetime.swift"
],
"target_dependencies" : [
"RediStack",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RediStackTestUtils",
"module_type" : "SwiftTarget",
"name" : "RediStackTestUtils",
"path" : "Sources/RediStackTestUtils",
"product_dependencies" : [
"NIOCore",
"NIOEmbedded"
],
"product_memberships" : [
"RediStackTestUtils"
],
"sources" : [
"EmbeddedMockRedisServer.swift",
"Extensions/General.swift",
"Extensions/RediStack.swift",
"RedisConnectionPoolIntegrationTestCase.swift",
"RedisIntegrationTestCase.swift",
"_Deprecations.swift"
],
"target_dependencies" : [
"RediStack"
],
"type" : "library"
},
{
"c99name" : "RediStackIntegrationTests",
"module_type" : "SwiftTarget",
"name" : "RediStackIntegrationTests",
"path" : "Tests/RediStackIntegrationTests",
"product_dependencies" : [
"NIO"
],
"sources" : [
"Commands/BasicCommandsTests.swift",
"Commands/HashCommandsTests.swift",
"Commands/ListCommandsTests.swift",
"Commands/PubSubCommandsTests.swift",
"Commands/SetCommandsTests.swift",
"Commands/SortedSetCommandsTests.swift",
"Commands/StringCommandsTests.swift",
"RediStackIntegrationTestCase.swift",
"RedisConnectionPoolTests.swift",
"RedisConnectionTests.swift",
"RedisLoggingTests.swift"
],
"target_dependencies" : [
"RediStack",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RediStack",
"module_type" : "SwiftTarget",
"name" : "RediStack",
"path" : "Sources/RediStack",
"product_dependencies" : [
"NIOCore",
"NIOPosix",
"NIO",
"NIOConcurrencyHelpers",
"NIOSSL",
"Atomics",
"Logging",
"Metrics"
],
"product_memberships" : [
"RediStack",
"RediStackTestUtils",
"RedisTypes"
],
"sources" : [
"ChannelHandlers/RedisByteDecoder.swift",
"ChannelHandlers/RedisCommandHandler.swift",
"ChannelHandlers/RedisMessageEncoder.swift",
"ChannelHandlers/RedisPubSubHandler.swift",
"Cluster/RedisClusterNodeDescriptionProtocol.swift",
"Cluster/RedisClusterNodeID.swift",
"Cluster/RedisClusterShardDescriptionProtocol.swift",
"Cluster/RedisHashSlot.swift",
"Cluster/SwiftPolyfill.swift",
"Commands/BasicCommands.swift",
"Commands/HashCommands.swift",
"Commands/ListCommands.swift",
"Commands/PubSubCommands.swift",
"Commands/SetCommands.swift",
"Commands/SortedSetCommands.swift",
"Commands/StringCommands.swift",
"ConnectionPool/ConnectionPool.swift",
"ConnectionPool/RedisConnectionPool+Configuration.swift",
"ConnectionPool/RedisConnectionPool.swift",
"ConnectionPool/RedisConnectionPoolError.swift",
"Extensions/StandardLibrary.swift",
"Extensions/SwiftNIO.swift",
"RESP/RESPTranslator.swift",
"RESP/RESPValue.swift",
"RESP/RESPValueConvertible.swift",
"RedisChannelName.swift",
"RedisClient.swift",
"RedisCommandEncoder-multi-encode.swift",
"RedisCommandEncoder.swift",
"RedisConnection+Configuration.swift",
"RedisConnection.swift",
"RedisError.swift",
"RedisKey+TTL.swift",
"RedisKey.swift",
"RedisLogging.swift",
"RedisMetrics.swift",
"_Deprecations.swift"
],
"type" : "library"
},
{
"c99name" : "RESP3Tests",
"module_type" : "SwiftTarget",
"name" : "RESP3Tests",
"path" : "Tests/RESP3Tests",
"product_dependencies" : [
"NIOCore",
"NIOEmbedded",
"NIOTestUtils"
],
"sources" : [
"RESP3TokenTests.swift"
],
"target_dependencies" : [
"RESP3"
],
"type" : "test"
},
{
"c99name" : "RESP3",
"module_type" : "SwiftTarget",
"name" : "RESP3",
"path" : "Sources/RESP3",
"product_dependencies" : [
"NIOCore"
],
"sources" : [
"RESP3Error.swift",
"RESP3Token.swift",
"RESP3TokenDecoder.swift",
"RESP3TypeIdentifier.swift"
],
"type" : "library"
}
],
"tools_version" : "5.6"
}
basic-6.1-latest: Pulling from finestructure/spi-images
Digest: sha256:3bdcac04179f4ed3e5b8e9dbd6e74bbf5ebc0f4fde48bbaad7d1e5c757e65bcb
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.1-latest
Done.