Merge pull request #1 from gal-yedidovich/improvement/async-bytes

Improvement/async bytes

Author: gal-yedidovich

Sources/SimpleEncryptor/CryptoService/AsyncChunkedSequence.swift

@@ -0,0 +1,41 @@
+//
+//  AsyncChunkedSequence.swift
+//  
+//
+//  Created by Gal Yedidovich on 05/12/2021.
+//
+
+
+@available(macOS 12.0, iOS 15.0, *)
+extension AsyncSequence {
+	func chunked(countOf chunkSize: Int) -> AsyncChunkedSequence<Self> {
+		AsyncChunkedSequence(sequence: self, chunkSize: chunkSize)
+	}
+}
+
+@available(macOS 12.0, iOS 15.0, *)
+struct AsyncChunkedSequence<AsyncSeq : AsyncSequence>: AsyncSequence {
+	typealias Element = [AsyncSeq.Element]
+	
+	let sequence: AsyncSeq
+	let chunkSize: Int
+	
+	func makeAsyncIterator() -> AsyncIterator {
+		AsyncIterator(innerIterator: sequence.makeAsyncIterator(), chunkSize: chunkSize)
+	}
+	
+	struct AsyncIterator: AsyncIteratorProtocol {
+		var innerIterator: AsyncSeq.AsyncIterator
+		let chunkSize: Int
+		
+		mutating func next() async throws -> Element? {
+			var chunk: Element = []
+			
+			while chunk.count < chunkSize, let value = try await innerIterator.next() {
+				chunk.append(value)
+			}
+			
+			return chunk.isEmpty ? nil : chunk
+		}
+	}
+}

Sources/SimpleEncryptor/CryptoService/ChaChaPolyService.swift

@@ -9,7 +9,7 @@ import Foundation
 import CryptoKit
 
 struct ChaChaPolyService: CryptoService {
-	private static let BUFFER_SIZE = 1024 * 32
+	static let BUFFER_SIZE = 1024 * 32
 
 	func encrypt(_ data: Data, using key: SymmetricKey) throws -> Data {
 		try ChaChaPoly.seal(data, using: key).combined

Sources/SimpleEncryptor/CryptoService/FileProcessing.swift

@@ -10,27 +10,28 @@ import CryptoKit
 
 typealias Operation = (Data) throws -> Data
 typealias FinalOperation = () throws -> Data
-typealias StreamsBlock = (InputStream, OutputStream) async throws -> ()
+typealias SafeStreamBlock = (OutputStream) async throws -> ()
 
 @available(macOS 12.0, iOS 15.0, *)
 func process(file src: URL, to dest: URL, using key: SymmetricKey, bufferSize: Int = 32 * 1000,
 			 operation: Operation, finalOperation: FinalOperation? = nil,
 			 onProgress: OnProgress?) async throws {
-	try await stream(from: src, to: dest) { input, output in
-		
-		guard let fileSize = src.fileSize else {
-			throw ProccessingError.fileNotFound
-		}
-		
+	guard let fileSize = src.fileSize else {
+		throw ProccessingError.fileNotFound
+	}
+	
+	try await safeStream(to: dest) { output in
 		var offset: Int = 0
 		var count = 0
 
-		try await input.readAll(bufferSize: bufferSize) { buffer, bytesRead in
-			offset += bytesRead
+		let batches = src.resourceBytes.chunked(countOf: bufferSize)
+		for try await batch in batches {
+			offset += batch.count
 			onProgress?(Int((offset * 100) / fileSize))
 
-			let data = Data(bytes: buffer, count: bytesRead)
-			output.write(data: try operation(data))
+			let processedData = try operation(Data(batch))
+			output.write(data: processedData)
+			
 			count = (count + 1) % 10
 			if count == 0 {
 				await Task.yield()
@@ -44,24 +45,21 @@ func process(file src: URL, to dest: URL, using key: SymmetricKey, bufferSize: I
 }
 
 @available(macOS 12.0, iOS 15.0, *)
-private func stream(from src: URL, to dest: URL, operation: StreamsBlock) async throws {
+private func safeStream(to dest: URL, operation: SafeStreamBlock) async throws {
 	let fm = FileManager.default
 
 	let tempDir = fm.temporaryDirectory
 	try fm.createDirectory(at: tempDir, withIntermediateDirectories: true, attributes: nil)
 	let tempFile = tempDir.appendingPathComponent(UUID().uuidString)
 
-	guard let input = InputStream(url: src) else {
-		throw ProccessingError.failedToCreateInputStream
-	}
 	guard let output = OutputStream(url: tempFile, append: false) else {
 		throw ProccessingError.failedToCreateOutputStream
 	}
 
 	output.open()
 	defer { output.close() }
 
-	try await operation(input, output)
+	try await operation(output)
 
 	if fm.fileExists(atPath: dest.path) {
 		try fm.removeItem(at: dest)
@@ -78,24 +76,6 @@ extension URL {
 	}
 }
 
-extension InputStream {
-	typealias Buffer = [UInt8]
-	
-	@available(macOS 12.0, iOS 15.0, *)
-	func readAll(bufferSize: Int, block: (Buffer, Int) async throws -> Void) async rethrows {
-		open()
-		defer { close() }
-		
-		var buffer = [UInt8](repeating: 0, count: bufferSize)
-		while hasBytesAvailable {
-			let bytesRead = read(&buffer, maxLength: buffer.count)
-			guard bytesRead > 0 else { break }
-			
-			try await block(buffer, bytesRead)
-		}
-	}
-}
-
 extension OutputStream {
 	func write(data: Data) {
 		let buffer = [UInt8](data)
@@ -105,13 +85,11 @@ extension OutputStream {
 
 enum ProccessingError: LocalizedError {
 	case fileNotFound
-	case failedToCreateInputStream
 	case failedToCreateOutputStream
 
 	var errorDescription: String? {
 		switch self {
 		case .fileNotFound: return "Source file not found"
-		case .failedToCreateInputStream: return "Failed to create input stream from source file"
 		case .failedToCreateOutputStream: return "Failed to create output stream to destination file"
 		}
 	}

Tests/Tests/SimpleEncryptorTests.swift

@@ -57,6 +57,33 @@ class SimpleEncryptorTests: XCTestCase {
 		}
 	}
 
+	@available(macOS 12.0, iOS 15.0, *)
+	func testShouldCallProgressTenTimes() async throws {
+		//Given
+		let BUFFER_SIZE: Int = ChaChaPolyService.BUFFER_SIZE
+		let EXPECTED_NUMBER_OF_STEPS = 10
+
+		let encryptor = SimpleEncryptor(type: .chachaPoly, keyService: MockKeyService())
+		let data = Data(randomString(length: BUFFER_SIZE * EXPECTED_NUMBER_OF_STEPS).utf8)
+		var count = 0
+		
+		let baseURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+		let url = baseURL.appendingPathComponent("data.txt")
+		let encUrl = baseURL.appendingPathComponent("enc_data.txt")
+		try data.write(to: url)
+		
+		//When
+		try await encryptor.encrypt(file: url, to: encUrl) { progress in
+			count += 1
+		}
+		
+		//Then
+		XCTAssertEqual(count, EXPECTED_NUMBER_OF_STEPS)
+		
+		try FileManager.default.removeItem(at: url)
+		try FileManager.default.removeItem(at: encUrl)
+	}
+	
 	private func testDataEncryption(withType type: CryptoServiceType) throws {
 		//Given
 		let encryptor = SimpleEncryptor(type: type, keyService: MockKeyService())