Also abort file backup while backup up a single huge file

previously switching to a metered network would have left the upload to continue until the file would be complete

Author: grote

storage/lib/src/main/java/org/calyxos/backup/storage/backup/ChunkWriter.kt

@@ -50,10 +50,12 @@ internal class ChunkWriter(
         inputStream: InputStream,
         chunks: List<Chunk>,
         missingChunkIds: List<String>,
+        wasAborted: () -> Boolean,
     ): ChunkWriterResult {
         var writtenChunks = 0
         var writtenBytes = 0L
         chunks.forEach { chunk ->
+            if (wasAborted()) throw IOException("Metered Network")
             val cachedChunk = chunksCache.get(chunk.id)
             // TODO missing chunks used by several files will get uploaded several times
             val isMissing = chunk.id in missingChunkIds

storage/lib/src/main/java/org/calyxos/backup/storage/backup/FileBackup.kt

@@ -44,7 +44,7 @@ internal class FileBackup(
         files.forEach { file ->
             if (wasAborted()) throw IOException("Metered Network")
             val result = try {
-                backupFile(file, availableChunkIds)
+                backupFile(file, availableChunkIds, wasAborted)
             } catch (e: IOException) {
                 backupObserver?.onFileBackupError(file, "L")
                 Log.e(TAG, "Error backing up ${file.uri}", e)
@@ -81,6 +81,7 @@ internal class FileBackup(
     private suspend fun backupFile(
         file: ContentFile,
         availableChunkIds: Set<String>,
+        wasAborted: () -> Boolean,
     ): FileBackupResult {
         val cachedFile = filesCache.getByUri(file.uri)
         val missingChunkIds = cachedFile?.chunks?.minus(availableChunkIds) ?: emptyList()
@@ -94,7 +95,7 @@ internal class FileBackup(
             chunker.makeChunks(inputStream)
         }
         val chunkWriterResult = uri.openInputStream(contentResolver).use { inputStream ->
-            chunkWriter.writeChunk(inputStream, chunks, missingChunkIds)
+            chunkWriter.writeChunk(inputStream, chunks, missingChunkIds, wasAborted)
         }
 
         val chunkIds = chunks.map { it.id }

storage/lib/src/test/java/org/calyxos/backup/storage/backup/ChunkWriterTest.kt

@@ -29,8 +29,10 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
+import java.io.IOException
 import java.io.OutputStream
 import kotlin.random.Random
+import kotlin.test.assertFailsWith
 
 internal class ChunkWriterTest {
 
@@ -116,7 +118,7 @@ internal class ChunkWriterTest {
         every { chunksCache.insert(chunks[1].toCachedChunk(3)) } just Runs
         every { chunksCache.insert(chunks[2].toCachedChunk(3)) } just Runs
 
-        chunkWriter.writeChunk(inputStream, chunks, emptyList())
+        chunkWriter.writeChunk(inputStream, chunks, emptyList()) { false }
 
         // check that version was written as the first byte
         outputStreams.forEach { outputStream ->
@@ -171,7 +173,7 @@ internal class ChunkWriterTest {
         // insert last not cached chunk into cache after upload
         every { chunksCache.insert(chunks[2].toCachedChunk(3)) } just Runs
 
-        chunkWriter.writeChunk(inputStream, chunks, listOf(chunkId1))
+        chunkWriter.writeChunk(inputStream, chunks, listOf(chunkId1)) { false }
 
         // check that output matches chunk data
         assertEquals(VERSION, chunk1Output.toByteArray()[0])
@@ -234,7 +236,7 @@ internal class ChunkWriterTest {
             chunksCache.insert(chunks[2].toCachedChunk(chunk3Bytes.size.toLong() + 1))
         } just Runs
 
-        chunkWriter.writeChunk(inputStream, chunks, emptyList())
+        chunkWriter.writeChunk(inputStream, chunks, emptyList()) { false }
 
         // check that version and wrapped key was written as the first byte
         outputStreams.forEach { outputStream ->
@@ -291,7 +293,7 @@ internal class ChunkWriterTest {
             chunksCache.insert(chunks[0].toCachedChunk(chunkBytes.size.toLong() + 1))
         } just Runs
 
-        chunkWriter.writeChunk(inputStream, chunks, emptyList())
+        chunkWriter.writeChunk(inputStream, chunks, emptyList()) { false }
 
         // check that output matches chunk data
         assertEquals(1 + chunks[0].plaintextSize.toInt(), chunkOutput1.size())
@@ -313,6 +315,20 @@ internal class ChunkWriterTest {
         assertEquals(chunkOutput3.size().toLong(), size2)
     }
 
+    @Test
+    fun testAbort() = runBlocking {
+        val chunkBytes = Random.nextBytes(16 * 1024 * 1024)
+        val inputStream = ByteArrayInputStream(chunkBytes)
+        val chunks = listOf(
+            Chunk(chunkId1, 0, chunkBytes.size.toLong()),
+        )
+
+        val e = assertFailsWith<IOException> {
+            chunkWriter.writeChunk(inputStream, chunks, emptyList()) { true }
+        }
+        assertEquals("Metered Network", e.message)
+    }
+
     private fun MockKMatcherScope.bytes(size: Int) = match<ByteArray> {
         it.size == size
     }