Jett Chen
GitHub
parent
df549d48e6
commit
abf1101484
43 changed files with 988 additions and 325 deletions
106
Apple/Shared/Client.swift
Normal file
106
Apple/Shared/Client.swift
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
import Foundation
|
||||
import Network
|
||||
|
||||
public final class Client {
|
||||
let connection: NWConnection
|
||||
|
||||
private let logger = Logger.logger(for: Client.self)
|
||||
private var generator = SystemRandomNumberGenerator()
|
||||
private var continuations: [UInt: UnsafeContinuation<Data, Error>] = [:]
|
||||
private var eventMap: [NotificationType: [(Data) throws -> Void]] = [:]
|
||||
private var task: Task<Void, Error>?
|
||||
|
||||
public convenience init() throws {
|
||||
self.init(url: try Constants.socketURL)
|
||||
}
|
||||
|
||||
public init(url: URL) {
|
||||
let endpoint: NWEndpoint
|
||||
if url.isFileURL {
|
||||
endpoint = .unix(path: url.path(percentEncoded: false))
|
||||
} else {
|
||||
endpoint = .url(url)
|
||||
}
|
||||
|
||||
let parameters = NWParameters.tcp
|
||||
parameters.defaultProtocolStack
|
||||
.applicationProtocols
|
||||
.insert(NWProtocolFramer.Options(definition: NewlineProtocolFramer.definition), at: 0)
|
||||
let connection = NWConnection(to: endpoint, using: parameters)
|
||||
connection.start(queue: .global())
|
||||
self.connection = connection
|
||||
self.task = Task { [weak self] in
|
||||
while true {
|
||||
let (data, _, _) = try await connection.receiveMessage()
|
||||
let peek = try JSONDecoder().decode(MessagePeek.self, from: data)
|
||||
switch peek.type {
|
||||
case .Response:
|
||||
let response = try JSONDecoder().decode(ResponsePeek.self, from: data)
|
||||
self?.logger.info("Received response for \(response.id)")
|
||||
guard let continuations = self?.continuations else {return}
|
||||
self?.logger.debug("All keys in continuation table: \(continuations.keys)")
|
||||
guard let continuation = self?.continuations[response.id] else { return }
|
||||
self?.logger.debug("Got matching continuation")
|
||||
continuation.resume(returning: data)
|
||||
case .Notification:
|
||||
let peek = try JSONDecoder().decode(NotificationPeek.self, from: data)
|
||||
guard let handlers = self?.eventMap[peek.method] else { continue }
|
||||
_ = try handlers.map { try $0(data) }
|
||||
default:
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
private func send<T: Request, U: Decodable>(_ request: T) async throws -> U {
|
||||
let data: Data = try await withUnsafeThrowingContinuation { continuation in
|
||||
continuations[request.id] = continuation
|
||||
do {
|
||||
let data = try JSONEncoder().encode(request)
|
||||
let completion: NWConnection.SendCompletion = .contentProcessed { error in
|
||||
guard let error = error else {
|
||||
return
|
||||
}
|
||||
continuation.resume(throwing: error)
|
||||
}
|
||||
connection.send(content: data, completion: completion)
|
||||
} catch {
|
||||
continuation.resume(throwing: error)
|
||||
return
|
||||
}
|
||||
}
|
||||
self.logger.debug("Got response data: \(String(describing: data.base64EncodedString()))")
|
||||
let res = try JSONDecoder().decode(Response<U>.self, from: data)
|
||||
self.logger.debug("Got response data decoded: \(String(describing: res))")
|
||||
return res.result
|
||||
}
|
||||
public func request<T: Codable, U: Decodable>(_ request: T, type: U.Type = U.self) async throws -> U {
|
||||
let req = BurrowRequest(
|
||||
id: generator.next(upperBound: UInt.max),
|
||||
command: request
|
||||
)
|
||||
return try await send(req)
|
||||
}
|
||||
public func single_request<U: Decodable>(_ request: String, type: U.Type = U.self) async throws -> U {
|
||||
let req = BurrowSimpleRequest(
|
||||
id: generator.next(upperBound: UInt.max),
|
||||
command: request
|
||||
)
|
||||
return try await send(req)
|
||||
}
|
||||
public func on_event<T: Codable>(_ event: NotificationType, callable: @escaping (T) throws -> Void) {
|
||||
let action = { data in
|
||||
let decoded = try JSONDecoder().decode(Notification<T>.self, from: data)
|
||||
try callable(decoded.params)
|
||||
}
|
||||
if eventMap[event] != nil {
|
||||
eventMap[event]?.append(action)
|
||||
} else {
|
||||
eventMap[event] = [action]
|
||||
}
|
||||
}
|
||||
|
||||
deinit {
|
||||
connection.cancel()
|
||||
}
|
||||
}
|
||||
|
|
@ -20,4 +20,14 @@ public enum Constants {
|
|||
}
|
||||
return .success(groupContainerURL)
|
||||
}()
|
||||
public static var socketURL: URL {
|
||||
get throws {
|
||||
try groupContainerURL.appending(component: "burrow.sock", directoryHint: .notDirectory)
|
||||
}
|
||||
}
|
||||
public static var dbURL: URL {
|
||||
get throws {
|
||||
try groupContainerURL.appending(component: "burrow.db", directoryHint: .notDirectory)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
139
Apple/Shared/DataTypes.swift
Normal file
139
Apple/Shared/DataTypes.swift
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
import Foundation
|
||||
|
||||
// swiftlint:disable identifier_name raw_value_for_camel_cased_codable_enum
|
||||
public enum BurrowError: Error {
|
||||
case addrDoesntExist
|
||||
case resultIsError
|
||||
case cantParseResult
|
||||
case resultIsNone
|
||||
case noClient
|
||||
}
|
||||
|
||||
public protocol Request: Codable where Params: Codable {
|
||||
associatedtype Params
|
||||
|
||||
var id: UInt { get set }
|
||||
var method: String { get set }
|
||||
var params: Params? { get set }
|
||||
}
|
||||
|
||||
public enum MessageType: String, Codable {
|
||||
case Request
|
||||
case Response
|
||||
case Notification
|
||||
}
|
||||
|
||||
public struct MessagePeek: Codable {
|
||||
public var type: MessageType
|
||||
public init(type: MessageType) {
|
||||
self.type = type
|
||||
}
|
||||
}
|
||||
|
||||
public struct BurrowSimpleRequest: Request {
|
||||
public var id: UInt
|
||||
public var method: String
|
||||
public var params: String?
|
||||
public init(id: UInt, command: String, params: String? = nil) {
|
||||
self.id = id
|
||||
self.method = command
|
||||
self.params = params
|
||||
}
|
||||
}
|
||||
|
||||
public struct BurrowRequest<T>: Request where T: Codable {
|
||||
public var id: UInt
|
||||
public var method: String
|
||||
public var params: T?
|
||||
public init(id: UInt, command: T) {
|
||||
self.id = id
|
||||
self.method = "\(T.self)"
|
||||
self.params = command
|
||||
}
|
||||
}
|
||||
|
||||
public struct Response<T>: Decodable where T: Decodable {
|
||||
public var id: UInt
|
||||
public var result: T
|
||||
public init(id: UInt, result: T) {
|
||||
self.id = id
|
||||
self.result = result
|
||||
}
|
||||
}
|
||||
|
||||
public struct ResponsePeek: Codable {
|
||||
public var id: UInt
|
||||
public init(id: UInt) {
|
||||
self.id = id
|
||||
}
|
||||
}
|
||||
|
||||
public enum NotificationType: String, Codable {
|
||||
case ConfigChange
|
||||
}
|
||||
|
||||
public struct Notification<T>: Codable where T: Codable {
|
||||
public var method: NotificationType
|
||||
public var params: T
|
||||
public init(method: NotificationType, params: T) {
|
||||
self.method = method
|
||||
self.params = params
|
||||
}
|
||||
}
|
||||
|
||||
public struct NotificationPeek: Codable {
|
||||
public var method: NotificationType
|
||||
public init(method: NotificationType) {
|
||||
self.method = method
|
||||
}
|
||||
}
|
||||
|
||||
public struct AnyResponseData: Codable {
|
||||
public var type: String
|
||||
public init(type: String) {
|
||||
self.type = type
|
||||
}
|
||||
}
|
||||
|
||||
public struct BurrowResult<T>: Codable where T: Codable {
|
||||
public var Ok: T?
|
||||
public var Err: String?
|
||||
public init(Ok: T, Err: String? = nil) {
|
||||
self.Ok = Ok
|
||||
self.Err = Err
|
||||
}
|
||||
}
|
||||
|
||||
public struct ServerConfig: Codable {
|
||||
public let address: [String]
|
||||
public let name: String?
|
||||
public let mtu: Int32?
|
||||
public init(address: [String], name: String?, mtu: Int32?) {
|
||||
self.address = address
|
||||
self.name = name
|
||||
self.mtu = mtu
|
||||
}
|
||||
}
|
||||
|
||||
public struct Start: Codable {
|
||||
public struct TunOptions: Codable {
|
||||
public let name: String?
|
||||
public let no_pi: Bool
|
||||
public let tun_excl: Bool
|
||||
public let tun_retrieve: Bool
|
||||
public let address: [String]
|
||||
public init(name: String?, no_pi: Bool, tun_excl: Bool, tun_retrieve: Bool, address: [String]) {
|
||||
self.name = name
|
||||
self.no_pi = no_pi
|
||||
self.tun_excl = tun_excl
|
||||
self.tun_retrieve = tun_retrieve
|
||||
self.address = address
|
||||
}
|
||||
}
|
||||
public let tun: TunOptions
|
||||
public init(tun: TunOptions) {
|
||||
self.tun = tun
|
||||
}
|
||||
}
|
||||
|
||||
// swiftlint:enable identifier_name raw_value_for_camel_cased_codable_enum
|
||||
32
Apple/Shared/NWConnection+Async.swift
Normal file
32
Apple/Shared/NWConnection+Async.swift
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
import Foundation
|
||||
import Network
|
||||
|
||||
extension NWConnection {
|
||||
// swiftlint:disable:next large_tuple
|
||||
func receiveMessage() async throws -> (Data, NWConnection.ContentContext?, Bool) {
|
||||
try await withUnsafeThrowingContinuation { continuation in
|
||||
receiveMessage { completeContent, contentContext, isComplete, error in
|
||||
if let error {
|
||||
continuation.resume(throwing: error)
|
||||
} else {
|
||||
guard let completeContent = completeContent else {
|
||||
fatalError("Both error and completeContent were nil")
|
||||
}
|
||||
continuation.resume(returning: (completeContent, contentContext, isComplete))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func send(content: Data) async throws {
|
||||
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
|
||||
send(content: content, completion: .contentProcessed { error in
|
||||
if let error {
|
||||
continuation.resume(throwing: error)
|
||||
} else {
|
||||
continuation.resume(returning: ())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
54
Apple/Shared/NewlineProtocolFramer.swift
Normal file
54
Apple/Shared/NewlineProtocolFramer.swift
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
import Foundation
|
||||
import Network
|
||||
|
||||
final class NewlineProtocolFramer: NWProtocolFramerImplementation {
|
||||
private static let delimeter: UInt8 = 10 // `\n`
|
||||
|
||||
static let definition = NWProtocolFramer.Definition(implementation: NewlineProtocolFramer.self)
|
||||
static let label = "Lines"
|
||||
|
||||
init(framer: NWProtocolFramer.Instance) { }
|
||||
|
||||
func start(framer: NWProtocolFramer.Instance) -> NWProtocolFramer.StartResult { .ready }
|
||||
func stop(framer: NWProtocolFramer.Instance) -> Bool { true }
|
||||
|
||||
func wakeup(framer: NWProtocolFramer.Instance) { }
|
||||
func cleanup(framer: NWProtocolFramer.Instance) { }
|
||||
|
||||
func handleInput(framer: NWProtocolFramer.Instance) -> Int {
|
||||
while true {
|
||||
var result: [Data] = []
|
||||
let parsed = framer.parseInput(minimumIncompleteLength: 1, maximumLength: 16_000) { buffer, _ in
|
||||
guard let buffer else { return 0 }
|
||||
var lines = buffer
|
||||
.split(separator: Self.delimeter, omittingEmptySubsequences: false)
|
||||
.map { Data($0) }
|
||||
guard lines.count > 1 else { return 0 }
|
||||
_ = lines.popLast()
|
||||
|
||||
result = lines
|
||||
return lines.reduce(lines.count) { $0 + $1.count }
|
||||
}
|
||||
|
||||
guard parsed && !result.isEmpty else { break }
|
||||
|
||||
for line in result {
|
||||
framer.deliverInput(data: line, message: .init(instance: framer), isComplete: true)
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func handleOutput(
|
||||
framer: NWProtocolFramer.Instance,
|
||||
message: NWProtocolFramer.Message,
|
||||
messageLength: Int,
|
||||
isComplete: Bool
|
||||
) {
|
||||
do {
|
||||
try framer.writeOutputNoCopy(length: messageLength)
|
||||
framer.writeOutput(data: [Self.delimeter])
|
||||
} catch {
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue