DbxClientV1: Clean up IOException separation.

Kannan Goundan · Kannan Goundan · commit 43efdce18cd8 · 2017-01-30T17:18:16.000-08:00
- Previously, we intercepted all HiddenExceptions.  Now, only intercept
  the instances that were thrown by our wrapper.
- Be more precise with our 'try' blocks to make sure the caller's
  exceptions get all the way through.
diff --git a/src/main/java/com/dropbox/core/NoThrowOutputStream.java b/src/main/java/com/dropbox/core/NoThrowOutputStream.java
@@ -42,7 +42,7 @@ public void flush()
             underlying.flush();
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -54,7 +54,7 @@ public void write(byte[] b, int off, int len)
             underlying.write(b, off, len);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -66,7 +66,7 @@ public void write(byte[] b)
             underlying.write(b);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -78,18 +78,24 @@ public void write(int b)
             underlying.write(b);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
     public static final class HiddenException extends RuntimeException
     {
-        public final IOException underlying;
+        public final NoThrowOutputStream owner;
 
-        public HiddenException(IOException underlying)
+        public HiddenException(NoThrowOutputStream owner, IOException underlying)
         {
             super(underlying);
-            this.underlying = underlying;
+            this.owner = owner;
+        }
+
+        @Override
+        public IOException getCause()
+        {
+            return (IOException) super.getCause();
         }
 
         public static final long serialVersionUID = 0;
diff --git a/src/main/java/com/dropbox/core/v1/DbxClientV1.java b/src/main/java/com/dropbox/core/v1/DbxClientV1.java
@@ -718,10 +718,8 @@ public <E extends Throwable> DbxEntry.File finishUploadFile(Uploader uploader, D
             return uploader.finish();
         }
         catch (NoThrowOutputStream.HiddenException ex) {
-            // We hid our OutputStream's IOException from their writer.write() function so that
-            // we could properly raise a NetworkIOException if something went wrong with the
-            // network stream.
-            throw new NetworkIOException(ex.underlying);
+            if (ex.owner == streamWrapper) throw new NetworkIOException(ex.getCause());
+            throw ex;
         }
         finally {
             uploader.close();
@@ -940,21 +938,29 @@ private <E extends Throwable> HttpRequestor.Response chunkedUploadCommon(String[
 
         HttpRequestor.Uploader uploader = DbxRequestUtil.startPut(requestConfig, accessToken, USER_AGENT_ID, host.getContent(), apiPath, params, headers);
         try {
+            NoThrowOutputStream nt = new NoThrowOutputStream(uploader.getBody());
             try {
-                NoThrowOutputStream nt = new NoThrowOutputStream(uploader.getBody());
+                // Any exceptions thrown by writer.write (e.g. IOException) are "owned" by
+                // the caller so let them propagate.  We should only handle exceptions caused
+                // by our uploader OutputStream.
                 writer.write(nt);
-                long bytesWritten = nt.getBytesWritten();
-                if (bytesWritten != chunkSize) {
-                    throw new IllegalStateException("'chunkSize' is " + chunkSize + ", but 'writer' only wrote " + bytesWritten + " bytes");
-                }
+            }
+            catch (NoThrowOutputStream.HiddenException ex) {
+                if (ex.owner == nt) throw new NetworkIOException(ex.getCause());
+                throw ex;
+            }
+
+            long bytesWritten = nt.getBytesWritten();
+            if (bytesWritten != chunkSize) {
+                throw new IllegalStateException("'chunkSize' is " + chunkSize + ", but 'writer' only wrote " + bytesWritten + " bytes");
+            }
+
+            try {
                 return uploader.finish();
             }
             catch (IOException ex) {
                 throw new NetworkIOException(ex);
             }
-            catch (NoThrowOutputStream.HiddenException ex) {
-                throw new NetworkIOException(ex.underlying);
-            }
         }
         finally {
             uploader.close();

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public void flush()`
`42`	`42`	`underlying.flush();`
`43`	`43`	`}`
`44`	`44`	`catch (IOException ex) {`
`45`		`- throw new HiddenException(ex);`
	`45`	`+ throw new HiddenException(this, ex);`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -54,7 +54,7 @@ public void write(byte[] b, int off, int len)`
`54`	`54`	`underlying.write(b, off, len);`
`55`	`55`	`}`
`56`	`56`	`catch (IOException ex) {`
`57`		`- throw new HiddenException(ex);`
	`57`	`+ throw new HiddenException(this, ex);`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`@@ -66,7 +66,7 @@ public void write(byte[] b)`
`66`	`66`	`underlying.write(b);`
`67`	`67`	`}`
`68`	`68`	`catch (IOException ex) {`
`69`		`- throw new HiddenException(ex);`
	`69`	`+ throw new HiddenException(this, ex);`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`@@ -78,18 +78,24 @@ public void write(int b)`
`78`	`78`	`underlying.write(b);`
`79`	`79`	`}`
`80`	`80`	`catch (IOException ex) {`
`81`		`- throw new HiddenException(ex);`
	`81`	`+ throw new HiddenException(this, ex);`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`public static final class HiddenException extends RuntimeException`
`86`	`86`	`{`
`87`		`- public final IOException underlying;`
	`87`	`+ public final NoThrowOutputStream owner;`
`88`	`88`
`89`		`- public HiddenException(IOException underlying)`
	`89`	`+ public HiddenException(NoThrowOutputStream owner, IOException underlying)`
`90`	`90`	`{`
`91`	`91`	`super(underlying);`
`92`		`- this.underlying = underlying;`
	`92`	`+ this.owner = owner;`
	`93`	`+ }`
	`94`	`+`
	`95`	`+ @Override`
	`96`	`+ public IOException getCause()`
	`97`	`+ {`
	`98`	`+ return (IOException) super.getCause();`
`93`	`99`	`}`
`94`	`100`
`95`	`101`	`public static final long serialVersionUID = 0;`