Throw the correct exception type

Author: lauzadis

runtime/runtime-core/api/runtime-core.api

@@ -760,6 +760,12 @@ public final class aws/smithy/kotlin/runtime/io/ClosedWriteChannelException : ja
 	public synthetic fun <init> (Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 }
 
+public class aws/smithy/kotlin/runtime/io/EOFException : java/io/EOFException {
+	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;)V
+	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
+}
+
 public final class aws/smithy/kotlin/runtime/io/GzipByteReadChannel : aws/smithy/kotlin/runtime/io/SdkByteReadChannel {
 	public fun <init> (Laws/smithy/kotlin/runtime/io/SdkByteReadChannel;)V
 	public fun cancel (Ljava/lang/Throwable;)Z

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/io/BuffereredSourceAdapter.kt

@@ -32,6 +32,17 @@ internal expect class BufferedSourceAdapter(source: okio.BufferedSource) : SdkBu
     override fun close()
 }
 
+/**
+ * Used to wrap calls to Okio, catching Okio exceptions (e.g. okio.EOFException) and throwing our own (e.g. aws.smithy.kotlin.runtime.io.EOFException).
+ */
+internal inline fun <T> SdkBufferedSource.wrapOkio(block: SdkBufferedSource.() -> T): T = try {
+    block()
+} catch (e: okio.EOFException) {
+    throw EOFException("Okio operation failed", e)
+} catch (e: okio.IOException) {
+    throw IOException("Okio operation failed", e)
+}
+
 // base class that fills in most of the common implementation, platforms just need to implement the platform specific
 // part of the interface
 internal abstract class AbstractBufferedSourceAdapter(
@@ -40,45 +51,57 @@ internal abstract class AbstractBufferedSourceAdapter(
     override val buffer: SdkBuffer
         get() = delegate.buffer.toSdk()
 
-    override fun skip(byteCount: Long): Unit = delegate.skip(byteCount)
+    override fun skip(byteCount: Long): Unit = wrapOkio { delegate.skip(byteCount) }
 
-    override fun readByte(): Byte = delegate.readByte()
+    override fun readByte(): Byte = wrapOkio { delegate.readByte() }
 
-    override fun readShort(): Short = delegate.readShort()
+    override fun readShort(): Short = wrapOkio { delegate.readShort() }
 
-    override fun readShortLe(): Short = delegate.readShortLe()
+    override fun readShortLe(): Short = wrapOkio { delegate.readShortLe() }
 
-    override fun readLong(): Long = delegate.readLong()
+    override fun readLong(): Long = wrapOkio { delegate.readLong() }
 
-    override fun readLongLe(): Long = delegate.readLongLe()
+    override fun readLongLe(): Long = wrapOkio { delegate.readLongLe() }
 
-    override fun readInt(): Int = delegate.readInt()
+    override fun readInt(): Int = wrapOkio { delegate.readInt() }
 
-    override fun readIntLe(): Int = delegate.readIntLe()
+    override fun readIntLe(): Int = wrapOkio { delegate.readIntLe() }
 
-    override fun readAll(sink: SdkSink): Long =
+    override fun readAll(sink: SdkSink): Long = wrapOkio {
         delegate.readAll(sink.toOkio())
+    }
 
-    override fun read(sink: ByteArray, offset: Int, limit: Int): Int =
+    override fun read(sink: ByteArray, offset: Int, limit: Int): Int = wrapOkio {
         delegate.read(sink, offset, limit)
+    }
 
-    override fun read(sink: SdkBuffer, limit: Long): Long =
+    override fun read(sink: SdkBuffer, limit: Long): Long = wrapOkio {
         delegate.read(sink.toOkio(), limit)
+    }
 
-    override fun readByteArray(): ByteArray = delegate.readByteArray()
+    override fun readByteArray(): ByteArray = wrapOkio { delegate.readByteArray() }
 
-    override fun readByteArray(byteCount: Long): ByteArray = delegate.readByteArray(byteCount)
+    override fun readByteArray(byteCount: Long): ByteArray = wrapOkio {
+        delegate.readByteArray(byteCount)
+    }
 
-    override fun readUtf8(): String = delegate.readUtf8()
+    override fun readUtf8(): String = wrapOkio { delegate.readUtf8() }
 
-    override fun readUtf8(byteCount: Long): String = delegate.readUtf8(byteCount)
+    override fun readUtf8(byteCount: Long): String = wrapOkio {
+        delegate.readUtf8(byteCount)
+    }
 
-    override fun peek(): SdkBufferedSource =
+    override fun peek(): SdkBufferedSource = wrapOkio {
         delegate.peek().toSdk().buffer()
-    override fun exhausted(): Boolean = delegate.exhausted()
-    override fun request(byteCount: Long): Boolean = delegate.request(byteCount)
+    }
+
+    override fun exhausted(): Boolean = wrapOkio { delegate.exhausted() }
+
+    override fun request(byteCount: Long): Boolean = wrapOkio {
+        delegate.request(byteCount)
+    }
 
-    override fun require(byteCount: Long): Unit = delegate.require(byteCount)
+    override fun require(byteCount: Long): Unit = wrapOkio { delegate.require(byteCount) }
 
-    override fun close() = delegate.close()
+    override fun close() = wrapOkio { delegate.close() }
 }

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/io/Exceptions.kt

@@ -10,8 +10,9 @@ public expect open class IOException(message: String?, cause: Throwable?) : Exce
     public constructor(message: String?)
 }
 
-public expect open class EOFException(message: String?) : IOException {
+public expect open class EOFException(message: String?, cause: Throwable?) : IOException {
     public constructor()
+    public constructor(message: String?)
 }
 
 /**

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/io/internal/BufferOperations.kt

@@ -9,95 +9,108 @@ package aws.smithy.kotlin.runtime.io.internal
 
 import aws.smithy.kotlin.runtime.io.*
 
-internal inline fun SdkBuffer.commonSkip(byteCount: Long) = inner.skip(byteCount)
+/**
+ * Used to wrap calls to Okio, catching Okio exceptions (e.g. okio.EOFException) and throwing our own (e.g. aws.smithy.kotlin.runtime.io.EOFException).
+ */
+internal inline fun <T> SdkBuffer.wrapOkio(block: SdkBuffer.() -> T): T = try {
+    block()
+} catch (e: okio.EOFException) {
+    throw EOFException("Okio operation failed", e)
+} catch (e: okio.IOException) {
+    throw IOException("Okio operation failed", e)
+}
+
+internal inline fun SdkBuffer.commonSkip(byteCount: Long) = wrapOkio { inner.skip(byteCount) }
 
-internal inline fun SdkBuffer.commonReadByte(): Byte = inner.readByte()
+internal inline fun SdkBuffer.commonReadByte(): Byte = wrapOkio { inner.readByte() }
 
-internal inline fun SdkBuffer.commonReadShort(): Short = inner.readShort()
+internal inline fun SdkBuffer.commonReadShort(): Short = wrapOkio { inner.readShort() }
 
-internal inline fun SdkBuffer.commonReadShortLe(): Short = inner.readShortLe()
+internal inline fun SdkBuffer.commonReadShortLe(): Short = wrapOkio { inner.readShortLe() }
 
-internal inline fun SdkBuffer.commonReadLong(): Long = inner.readLong()
+internal inline fun SdkBuffer.commonReadLong(): Long = wrapOkio { inner.readLong() }
 
-internal inline fun SdkBuffer.commonReadLongLe(): Long = inner.readLongLe()
+internal inline fun SdkBuffer.commonReadLongLe(): Long = wrapOkio { inner.readLongLe() }
 
-internal inline fun SdkBuffer.commonReadInt(): Int = inner.readInt()
+internal inline fun SdkBuffer.commonReadInt(): Int = wrapOkio { inner.readInt() }
 
-internal inline fun SdkBuffer.commonReadIntLe(): Int = inner.readIntLe()
+internal inline fun SdkBuffer.commonReadIntLe(): Int = wrapOkio { inner.readIntLe() }
 
-internal inline fun SdkBuffer.commonReadAll(sink: SdkSink): Long =
-    inner.readAll(sink.toOkio())
+internal inline fun SdkBuffer.commonReadAll(sink: SdkSink): Long = wrapOkio { inner.readAll(sink.toOkio()) }
 
 internal inline fun SdkBuffer.commonRead(sink: ByteArray, offset: Int, limit: Int): Int =
-    inner.read(sink, offset, limit)
+    wrapOkio { inner.read(sink, offset, limit) }
 
 internal inline fun SdkBuffer.commonRead(sink: SdkBuffer, limit: Long): Long =
-    inner.read(sink.inner, limit)
+    wrapOkio { inner.read(sink.inner, limit) }
 
-internal inline fun SdkBuffer.commonReadByteArray(): ByteArray = inner.readByteArray()
+internal inline fun SdkBuffer.commonReadByteArray(): ByteArray = wrapOkio { inner.readByteArray() }
 
-internal inline fun SdkBuffer.commonReadByteArray(byteCount: Long): ByteArray = inner.readByteArray(byteCount)
+internal inline fun SdkBuffer.commonReadByteArray(byteCount: Long): ByteArray = wrapOkio { inner.readByteArray(byteCount) }
 
-internal inline fun SdkBuffer.commonReadUtf8(): String = inner.readUtf8()
+internal inline fun SdkBuffer.commonReadUtf8(): String = wrapOkio { inner.readUtf8() }
 
-internal inline fun SdkBuffer.commonReadUtf8(byteCount: Long): String = inner.readUtf8(byteCount)
+internal inline fun SdkBuffer.commonReadUtf8(byteCount: Long): String = wrapOkio { inner.readUtf8(byteCount) }
 
-internal inline fun SdkBuffer.commonPeek(): SdkBufferedSource = inner.peek().toSdk().buffer()
-internal inline fun SdkBuffer.commonExhausted(): Boolean = inner.exhausted()
-internal inline fun SdkBuffer.commonRequest(byteCount: Long): Boolean = inner.request(byteCount)
+internal inline fun SdkBuffer.commonPeek(): SdkBufferedSource = wrapOkio { inner.peek().toSdk().buffer() }
 
-internal inline fun SdkBuffer.commonRequire(byteCount: Long): Unit = inner.require(byteCount)
+internal inline fun SdkBuffer.commonExhausted(): Boolean = wrapOkio { inner.exhausted() }
+
+internal inline fun SdkBuffer.commonRequest(byteCount: Long): Boolean = wrapOkio { inner.request(byteCount) }
+
+internal inline fun SdkBuffer.commonRequire(byteCount: Long) = wrapOkio { inner.require(byteCount) }
 
 internal inline fun SdkBuffer.commonWrite(source: ByteArray, offset: Int, limit: Int) {
-    inner.write(source, offset, limit)
+    wrapOkio { inner.write(source, offset, limit) }
 }
 
 internal inline fun SdkBuffer.commonWrite(source: SdkSource, byteCount: Long) {
-    inner.write(source.toOkio(), byteCount)
+    wrapOkio { inner.write(source.toOkio(), byteCount) }
 }
+
 internal inline fun SdkBuffer.commonWrite(source: SdkBuffer, byteCount: Long) {
-    inner.write(source.toOkio(), byteCount)
+    wrapOkio { inner.write(source.toOkio(), byteCount) }
 }
 
 internal inline fun SdkBuffer.commonWriteAll(source: SdkSource): Long =
-    inner.writeAll(source.toOkio())
+    wrapOkio { inner.writeAll(source.toOkio()) }
 
 internal inline fun SdkBuffer.commonWriteUtf8(string: String, start: Int, endExclusive: Int) {
-    inner.writeUtf8(string, start, endExclusive)
+    wrapOkio { inner.writeUtf8(string, start, endExclusive) }
 }
 
 internal inline fun SdkBuffer.commonWriteByte(x: Byte) {
-    inner.writeByte(x.toInt())
+    wrapOkio { inner.writeByte(x.toInt()) }
 }
 
 internal inline fun SdkBuffer.commonWriteShort(x: Short) {
-    inner.writeShort(x.toInt())
+    wrapOkio { inner.writeShort(x.toInt()) }
 }
 
 internal inline fun SdkBuffer.commonWriteShortLe(x: Short) {
-    inner.writeShortLe(x.toInt())
+    wrapOkio { inner.writeShortLe(x.toInt()) }
 }
 
 internal inline fun SdkBuffer.commonWriteInt(x: Int) {
-    inner.writeInt(x)
+    wrapOkio { inner.writeInt(x) }
 }
 
 internal inline fun SdkBuffer.commonWriteIntLe(x: Int) {
-    inner.writeIntLe(x)
+    wrapOkio { inner.writeIntLe(x) }
 }
 
 internal inline fun SdkBuffer.commonWriteLong(x: Long) {
-    inner.writeLong(x)
+    wrapOkio { inner.writeLong(x) }
 }
 
 internal inline fun SdkBuffer.commonWriteLongLe(x: Long) {
-    inner.writeLongLe(x)
+    wrapOkio { inner.writeLongLe(x) }
 }
 
 internal inline fun SdkBuffer.commonFlush() {
-    inner.flush()
+    wrapOkio { inner.flush() }
 }
 
 internal inline fun SdkBuffer.commonClose() {
-    inner.close()
+    wrapOkio { inner.close() }
 }

runtime/runtime-core/jvm/src/aws/smithy/kotlin/runtime/io/ExceptionsJVM.kt

@@ -7,4 +7,14 @@ package aws.smithy.kotlin.runtime.io
 
 public actual typealias IOException = java.io.IOException
 
-public actual typealias EOFException = java.io.EOFException
+public actual open class EOFException actual constructor(
+    message: String?,
+    cause: Throwable?
+) : java.io.EOFException(message) {
+    init {
+        initCause(cause)
+    }
+
+    public actual constructor() : this(null, null)
+    public actual constructor(message: String?) : this(message, null)
+}

runtime/runtime-core/native/src/aws/smithy/kotlin/runtime/io/ExceptionsNative.kt

@@ -12,6 +12,7 @@ public actual open class IOException actual constructor(
     public actual constructor(message: String?) : this(message, null)
 }
 
-public actual open class EOFException actual constructor(message: String?) : IOException(message) {
-    public actual constructor() : this(null)
+public actual open class EOFException actual constructor(message: String?, cause: Throwable?) : IOException(message) {
+    public actual constructor() : this(null, null)
+    public actual constructor(message: String?) : this(message, null)
 }