@bravemobile/react-native-code-push 13.1.0-beta.3 → 13.1.0-beta.5

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushErrorCode.java

@@ -0,0 +1,86 @@
+package com.microsoft.codepush.react;
+
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+
+import javax.net.ssl.SSLException;
+
+/**
+ * What kind of failure a download ended in, in the words JS reads it by.
+ *
+ * React Native fills the code of a promise rejected with a bare throwable with
+ * `EUNSPECIFIED`, which left the message the only thing telling one failure apart from
+ * another - and a message is written for a person, not for a report to group by.
+ *
+ * The categories are the ones that ask for different things to happen next, which is why
+ * there are four of them rather than one per way a download can fail. A category no
+ * caller would act differently on is a category that only makes the reports wider.
+ */
+public class CodePushErrorCode {
+
+    /** The network did not carry the download: the socket dropped, timed out, or never opened. */
+    public static final String NETWORK = "CODE_PUSH_NETWORK";
+
+    /** The server answered, with a status that is not a body to install. */
+    public static final String HTTP = "CODE_PUSH_HTTP";
+
+    /**
+     * The downloaded contents do not hash to the release's package hash, or hold no JS
+     * bundle by the name the app looks for. Downloading them again cannot help.
+     */
+    public static final String INTEGRITY = "CODE_PUSH_INTEGRITY";
+
+    /** Nothing here has a word for it, and inventing one would only be a guess. */
+    public static final String UNKNOWN = "CODE_PUSH_UNKNOWN";
+
+    private CodePushErrorCode() {
+    }
+
+    /**
+     * The category of a failure, read through its causes: the download wraps some of what it
+     * catches, and the wrapper is never the part that says what went wrong.
+     */
+    public static String of(Throwable error) {
+        for (Throwable cause = error; cause != null; cause = cause.getCause()) {
+            if (cause instanceof CodePushHttpException) {
+                return HTTP;
+            }
+
+            if (cause instanceof CodePushInvalidUpdateException) {
+                return INTEGRITY;
+            }
+
+            if (isTransportFailure(cause)) {
+                return NETWORK;
+            }
+        }
+
+        return UNKNOWN;
+    }
+
+    /**
+     * Whether the download failed because the network did not carry it.
+     *
+     * A server that answered is not this, however it answered: the connection worked, and
+     * asking a different URL over it is worth doing. A connection that never opened or that
+     * dropped is, and every URL behind it is equally out of reach.
+     */
+    public static boolean isNetworkFailure(Throwable error) {
+        return NETWORK.equals(of(error));
+    }
+
+    private static boolean isTransportFailure(Throwable error) {
+        // `SocketException` is the one that covers the reported majority - the connection
+        // reset and the connection aborted an app being backgrounded mid-download leaves
+        // behind - along with the connection that was refused or had no route.
+        //
+        // A download that stopped short belongs here too. The socket raised nothing for it,
+        // so only the byte count says the network dropped the rest of the body.
+        return error instanceof SocketTimeoutException
+                || error instanceof SocketException
+                || error instanceof UnknownHostException
+                || error instanceof SSLException
+                || error instanceof CodePushIncompleteDownloadException;
+    }
+}

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushHttpException.java

@@ -0,0 +1,29 @@
+package com.microsoft.codepush.react;
+
+import java.io.IOException;
+
+/**
+ * The server answered a download with a status that is not a body to install.
+ *
+ * An I/O exception rather than one of this package's unchecked ones, because every caller
+ * of a download already handles `IOException` and this is one more way a download does not
+ * arrive - and because the alternative, an unchecked exception, would escape the download
+ * path uncaught.
+ *
+ * The message reads the way the other platform's does, so one release answered with the
+ * same status reads the same in both platforms' reports.
+ */
+public class CodePushHttpException extends IOException {
+
+    private final int mStatusCode;
+
+    public CodePushHttpException(String url, int statusCode) {
+        super("Received " + statusCode + " response from " + url);
+        mStatusCode = statusCode;
+    }
+
+    /** The status the server answered with. */
+    public int getStatusCode() {
+        return mStatusCode;
+    }
+}

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushIncompleteDownloadException.java

@@ -0,0 +1,17 @@
+package com.microsoft.codepush.react;
+
+import java.io.IOException;
+
+/**
+ * The response stopped before it had delivered the length it declared.
+ *
+ * A type of its own rather than one more unnamed I/O error, because this is a network
+ * failure the socket never raised one for: the bytes simply stopped arriving, and only the
+ * count says so. Everywhere a network failure is acted on has to act on this one too.
+ */
+public class CodePushIncompleteDownloadException extends IOException {
+
+    public CodePushIncompleteDownloadException(long receivedBytes, long declaredBytes) {
+        super("Received " + receivedBytes + " bytes, expected " + declaredBytes);
+    }
+}

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -336,7 +336,7 @@ public class CodePushNativeModule extends NativeCodePushSpec {
             public void run() {
                 try {
                     JSONObject mutableUpdatePackage = CodePushUtils.convertReadableToJsonObject(updatePackage);
-                    JSONObject binaryPatchResult = mUpdateManager.downloadPackage(mutableUpdatePackage, mCodePush.getAssetsBundleFileName(), new DownloadProgressCallback() {
+                    JSONObject updateArchiveResult = mUpdateManager.downloadPackage(mutableUpdatePackage, mCodePush.getAssetsBundleFileName(), new DownloadProgressCallback() {
                         private volatile boolean hasScheduledNextFrame = false;
                         private final DownloadProgressEventDispatcher progressEventDispatcher = new DownloadProgressEventDispatcher(
                                 new DownloadProgressEventDispatcher.EventEmitter() {
@@ -389,23 +389,28 @@ public class CodePushNativeModule extends NativeCodePushSpec {
 
                     JSONObject newPackage = mUpdateManager.getPackage(CodePushUtils.tryGetString(updatePackage, CodePushConstants.PACKAGE_HASH_KEY));
                     WritableMap downloadedPackage = CodePushUtils.convertJsonObjectToWritable(newPackage);
-                    if (binaryPatchResult != null) {
+                    if (updateArchiveResult != null) {
                         // The result describes this download rather than the update, so it is
                         // put on what this call resolves with and nowhere else: the metadata
                         // the update manager has already written knows nothing about it, and
                         // whoever asked for the download decides what the result is worth.
-                        downloadedPackage.putMap(CodePushConstants.BINARY_PATCH_RESULT_KEY,
-                                CodePushUtils.convertJsonObjectToWritable(binaryPatchResult));
+                        downloadedPackage.putMap(CodePushConstants.UPDATE_ARCHIVE_RESULT_KEY,
+                                CodePushUtils.convertJsonObjectToWritable(updateArchiveResult));
                     }
 
                     promise.resolve(downloadedPackage);
                 } catch (CodePushInvalidUpdateException e) {
                     CodePushUtils.log(e);
                     mSettingsManager.saveFailedUpdate(CodePushUtils.convertReadableToJsonObject(updatePackage));
-                    promise.reject(e);
-                } catch (IOException | CodePushUnknownException e) {
+                    promise.reject(CodePushErrorCode.of(e), e.getMessage(), e);
+                } catch (Throwable e) {
+                    // Anything at all, because a promise is waiting on this. A failure that
+                    // leaves this method without settling it leaves JS waiting on a download
+                    // that is no longer running, with nothing to time it out. The narrower
+                    // catch this replaces let two through: a download URL that is not a URL,
+                    // and an archive naming a path outside the folder it unpacks into.
                     CodePushUtils.log(e);
-                    promise.reject(e);
+                    promise.reject(CodePushErrorCode.of(e), e.getMessage(), e);
                 }
             }
         });

package/android/app/src/main/java/com/microsoft/codepush/react/CodePushUpdateManager.java

@@ -157,20 +157,46 @@ public class CodePushUpdateManager {
     }
 
     /**
-     * @return what the attempt at installing the update from its binary patch archive ended
-     *         in, or null when the update had no patch archive to attempt. The result belongs
+     * @return what the attempts at installing the update from its patch archives ended in,
+     *         or null when the update had no such archive to attempt. The result belongs
      *         to this download alone: the metadata written for the update never carries it.
      */
     public JSONObject downloadPackage(JSONObject updatePackage, String expectedBundleFileName,
                                       DownloadProgressCallback progressCallback) throws IOException {
-        // A release that was published with a binary patch offers two archives of the same
-        // update. The patch is worth trying because it is a fraction of the size, and the
-        // full archive is always there when it does not work out.
-        String binaryPatchDownloadUrl = updatePackage.optString(CodePushConstants.BINARY_PATCH_DOWNLOAD_URL_KEY, null);
-        BinaryPatchAttempt patchAttempt = null;
-        if (binaryPatchDownloadUrl != null) {
-            patchAttempt = new BinaryPatchAttempt();
-            if (tryDownloadBinaryPatchPackage(updatePackage, expectedBundleFileName, progressCallback,
+        // A release that was published with a binary patch offers up to three archives of
+        // the same update. The asset diff is the smallest and is tried first, the patch
+        // archive stands in when the diff fails on its asset side, and the full archive is
+        // always there when none of it works out.
+        String binaryPatchDownloadUrl = optArchiveDownloadUrl(updatePackage, CodePushConstants.BINARY_PATCH_DOWNLOAD_URL_KEY);
+        String assetDiffDownloadUrl = optArchiveDownloadUrl(updatePackage, CodePushConstants.ASSET_DIFF_DOWNLOAD_URL_KEY);
+
+        ArchiveAttemptLog patchAttempt = null;
+        boolean patchArchiveWorthTrying = binaryPatchDownloadUrl != null;
+        if (assetDiffDownloadUrl != null) {
+            patchAttempt = new ArchiveAttemptLog();
+            patchAttempt.beginAttempt(ArchiveAttemptLog.ARCHIVE_ASSET_DIFF);
+            if (tryDownloadArchivePackage(updatePackage, expectedBundleFileName, progressCallback,
+                    assetDiffDownloadUrl, patchAttempt)) {
+                return patchAttempt.result();
+            }
+
+            // The patch archive is worth trying when nothing about how the diff failed
+            // implicates it. A diff that failed after restoring its bundle failed on its
+            // asset side, which the patch archive does not share; a diff the server never
+            // served is a verdict on one URL, and the patch archive is at another. Anything
+            // else failed in the bundle patch both archives carry byte for byte, so the
+            // patch archive would fail the same way and trying it would only put a second
+            // doomed download in front of the full one.
+            patchArchiveWorthTrying = patchArchiveWorthTrying
+                    && (patchAttempt.currentAttemptRestoredBundle() || patchAttempt.currentAttemptWasNotServed());
+        }
+
+        if (patchArchiveWorthTrying) {
+            if (patchAttempt == null) {
+                patchAttempt = new ArchiveAttemptLog();
+            }
+            patchAttempt.beginAttempt(ArchiveAttemptLog.ARCHIVE_BINARY_PATCH);
+            if (tryDownloadArchivePackage(updatePackage, expectedBundleFileName, progressCallback,
                     binaryPatchDownloadUrl, patchAttempt)) {
                 return patchAttempt.result();
             }
@@ -183,40 +209,71 @@ public class CodePushUpdateManager {
     }
 
     /**
-     * Installs the update from its binary patch archive.
+     * @return the URL one of the update's archives is offered at, or null when the update
+     *         does not offer that archive. An empty string is not a URL: it stands for the
+     *         same absent archive as a missing key, which is what iOS makes of it too.
+     */
+    private static String optArchiveDownloadUrl(JSONObject updatePackage, String downloadUrlKey) {
+        String downloadUrl = updatePackage.optString(downloadUrlKey, null);
+        return downloadUrl == null || downloadUrl.isEmpty() ? null : downloadUrl;
+    }
+
+    /**
+     * Installs the update from one of its patch archives.
      *
-     * Every way this can fail ends the same way, with the update being downloaded in full
-     * instead, so none of them is reported to the caller as an error. The fallback happens
-     * exactly once without anything having to count it: the full archive is downloaded by
-     * a call that is not allowed to take the patch path, so it has no failure of its own to
-     * fall back from.
+     * Every verdict on the archive ends the same way, with the caller moving on to the next
+     * one, so none of it is reported to the caller as an error. A network that did not carry
+     * the archive is not a verdict on it and is raised instead. The ladder cannot loop:
+     * which archive comes next is the caller's decision alone, and the full archive at its
+     * end is downloaded by a call that is not allowed to take the patch path, so it has no
+     * failure of its own to fall back from.
      *
      * @param patchAttempt records what the attempt ended in, for the caller to hand to
      *                     whoever asked for the download
-     * @return true when the update was installed, false when the caller has to download the
-     *         full archive instead
+     * @return true when the update was installed, false when the caller has to move on to
+     *         the next archive
+     * @throws IOException when the network did not carry the archive, which is not a verdict
+     *                     on the archive and so is not a reason to try another one
      */
-    private boolean tryDownloadBinaryPatchPackage(JSONObject updatePackage, String expectedBundleFileName,
-                                                  DownloadProgressCallback progressCallback,
-                                                  String binaryPatchDownloadUrl, BinaryPatchAttempt patchAttempt) {
+    private boolean tryDownloadArchivePackage(JSONObject updatePackage, String expectedBundleFileName,
+                                              DownloadProgressCallback progressCallback,
+                                              String archiveDownloadUrl, ArchiveAttemptLog patchAttempt)
+            throws IOException {
         try {
-            BinaryPatchResult patchResult = downloadAndInstallPackage(updatePackage, expectedBundleFileName,
-                    progressCallback, binaryPatchDownloadUrl, true, patchAttempt);
+            ArchiveRestoreResult patchResult = downloadAndInstallPackage(updatePackage, expectedBundleFileName,
+                    progressCallback, archiveDownloadUrl, true, patchAttempt);
             if (patchResult.succeeded()) {
                 return true;
             }
 
             patchAttempt.recordFallback(patchResult.getFailureReason());
-            CodePushUtils.log("Binary patch update failed (" + patchResult.getFailureReason()
-                    + "). Downloading the full update instead.");
+            CodePushUtils.log("The " + patchAttempt.currentArchive() + " archive failed ("
+                    + patchResult.getFailureReason() + "). Falling back.");
         } catch (Exception | OutOfMemoryError e) {
+            if (CodePushErrorCode.isNetworkFailure(e)) {
+                // The network is what failed, not the archive, and the full archive is behind
+                // the same network - only larger, and started over from nothing. Falling back
+                // here would spend a second download to reach the failure already in hand.
+                CodePushUtils.log("The " + patchAttempt.currentArchive()
+                        + " archive could not be downloaded. Giving up on the download.");
+                if (e instanceof IOException) {
+                    throw (IOException) e;
+                }
+
+                // A network failure read out of a wrapper this package raised, which the
+                // caller catches by its own type rather than by `IOException`.
+                throw new CodePushUnknownException(
+                        "The " + patchAttempt.currentArchive() + " archive could not be downloaded.", e);
+            }
+
             // Applying a patch is the one path that holds a whole bundle in memory, so
             // running out of it is a failure this has to absorb like any other: by the time
             // it lands here the arrays are unreachable, and the full archive is downloaded
             // to disk in chunks rather than held.
-            patchAttempt.recordFallbackAfterError();
+            patchAttempt.recordFallbackAfterError(e);
             CodePushUtils.log(e);
-            CodePushUtils.log("The binary patch update could not be completed. Downloading the full update instead.");
+            CodePushUtils.log("The " + patchAttempt.currentArchive()
+                    + " archive could not be applied. Falling back.");
         } finally {
             FileUtils.deleteDirectoryAtPath(getBinaryPatchFolderPath());
         }
@@ -229,19 +286,19 @@ public class CodePushUpdateManager {
      *
      * @param isBinaryPatchUpdate whether the archive holds a binary patch of the JS bundle,
      *                            which has to be applied before the contents are the update.
-     *                            Only an archive downloaded from the binary patch URL is
-     *                            treated that way, so an update being downloaded in full can
-     *                            never end up on the patch path.
+     *                            Both the asset diff and the patch archive are downloaded
+     *                            that way; the full archive never is, so an update being
+     *                            downloaded in full can never end up on the patch path.
      * @param patchAttempt the record the patch is timed into, or null for a full download,
      *                     which has no patch to time
      * @return the outcome of the patch: a failed result means the update was not installed
-     *         and the caller has to fall back to the full archive. Downloading the full
+     *         and the caller has to move on to the next archive. Downloading the full
      *         archive always succeeds or throws.
      */
-    BinaryPatchResult downloadAndInstallPackage(JSONObject updatePackage, String expectedBundleFileName,
+    ArchiveRestoreResult downloadAndInstallPackage(JSONObject updatePackage, String expectedBundleFileName,
                                                 DownloadProgressCallback progressCallback,
                                                 String downloadUrlString, boolean isBinaryPatchUpdate,
-                                                BinaryPatchAttempt patchAttempt) throws IOException {
+                                                ArchiveAttemptLog patchAttempt) throws IOException {
         String newUpdateHash = updatePackage.optString(CodePushConstants.PACKAGE_HASH_KEY, null);
         String newUpdateFolderPath = getPackageFolderPath(newUpdateHash);
         String newUpdateMetadataPath = CodePushUtils.appendPathComponent(newUpdateFolderPath, CodePushConstants.PACKAGE_FILE_NAME);
@@ -262,6 +319,8 @@ public class CodePushUpdateManager {
         try {
             URL downloadUrl = new URL(downloadUrlString);
             connection = (HttpURLConnection) (downloadUrl.openConnection());
+            connection.setConnectTimeout(CodePushConstants.DOWNLOAD_CONNECT_TIMEOUT_IN_MS);
+            connection.setReadTimeout(CodePushConstants.DOWNLOAD_READ_TIMEOUT_IN_MS);
 
             if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP &&
                 downloadUrl.toString().startsWith("https")) {
@@ -273,6 +332,15 @@ public class CodePushUpdateManager {
             }
 
             connection.setRequestProperty("Accept-Encoding", "identity");
+
+            // Read before the body is: an error status carries a body of its own, and
+            // asking `getInputStream()` for it first turns some statuses into a stream and
+            // others into an exception that says nothing about which status it was.
+            int responseCode = connection.getResponseCode();
+            if (responseCode >= 400) {
+                throw new CodePushHttpException(downloadUrlString, responseCode);
+            }
+
             bin = new BufferedInputStream(connection.getInputStream());
 
             // Announced only once the response is flowing, so a connection that fails to
@@ -313,8 +381,11 @@ public class CodePushUpdateManager {
                 progressCallback.call(new DownloadProgress(totalBytes, receivedBytes));
             }
 
-            if (totalBytes != receivedBytes) {
-                throw new CodePushUnknownException("Received " + receivedBytes + " bytes, expected " + totalBytes);
+            // Only against a length the server declared. `getContentLength()` answers -1
+            // for a body sent without one, which no read total matches - so comparing anyway
+            // would fail every download a server chooses to send that way.
+            if (totalBytes >= 0 && totalBytes != receivedBytes) {
+                throw new CodePushIncompleteDownloadException(receivedBytes, totalBytes);
             }
 
             isZip = ByteBuffer.wrap(header).getInt() == 0x504b0304;
@@ -341,7 +412,7 @@ public class CodePushUpdateManager {
             // contents identical to the ones the full archive would have delivered.
             if (isBinaryPatchUpdate) {
                 long patchStartTime = System.currentTimeMillis();
-                BinaryPatchResult patchResult = mBinaryPatch.restoreBundle(unzippedFolderPath,
+                ArchiveRestoreResult patchResult = mBinaryPatch.restoreBundle(unzippedFolderPath,
                         getBinaryPatchFolderPath(), expectedBundleFileName);
                 if (!patchResult.succeeded()) {
                     return patchResult;
@@ -357,10 +428,31 @@ public class CodePushUpdateManager {
                     CodePushConstants.DIFF_MANIFEST_FILE_NAME);
             boolean isDiffUpdate = FileUtils.fileAtPathExists(diffManifestFilePath);
             if (isDiffUpdate) {
-                String currentPackageFolderPath = getCurrentPackageFolderPath();
-                CodePushUpdateUtils.copyNecessaryFilesFromCurrentPackage(diffManifestFilePath, currentPackageFolderPath, newUpdateFolderPath);
-                File diffManifestFile = new File(diffManifestFilePath);
-                diffManifestFile.delete();
+                try {
+                    String currentPackageFolderPath = getCurrentPackageFolderPath();
+                    if (currentPackageFolderPath != null && !FileUtils.fileAtPathExists(currentPackageFolderPath)) {
+                        // The copy below skips a package that is gone and lets the merge
+                        // "complete" without it, which would report the missing package as a
+                        // verification failure of the merged contents. The other platform's
+                        // merge fails reading the missing files, so it is refused here too,
+                        // for the two platforms to report one reason for one state.
+                        throw new IOException("The installed package the diff merges into is gone from " + currentPackageFolderPath);
+                    }
+
+                    CodePushUpdateUtils.copyNecessaryFilesFromCurrentPackage(diffManifestFilePath, currentPackageFolderPath, newUpdateFolderPath);
+                    File diffManifestFile = new File(diffManifestFilePath);
+                    diffManifestFile.delete();
+                } catch (Exception e) {
+                    // A merge that cannot complete has a word of its own, because it says
+                    // the diff went wrong on its asset side - the one failure the patch
+                    // archive, which carries every asset, is not implicated in.
+                    if (isBinaryPatchUpdate) {
+                        CodePushUtils.log(e);
+                        return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_ASSET_MERGE_FAILED);
+                    }
+
+                    throw e;
+                }
             }
 
             FileUtils.copyDirectoryContents(unzippedFolderPath, newUpdateFolderPath);
@@ -389,11 +481,11 @@ public class CodePushUpdateManager {
             }
         } else {
             if (isBinaryPatchUpdate) {
-                // Whatever the patch URL served, it is not a patch archive - an error page
+                // Whatever the archive URL served, it is not an update archive - an error page
                 // answered with a 200 looks like this too. Moving it into place would
                 // install bytes no hash has ever been checked against, so the full archive
                 // is downloaded instead.
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_INVALID_MANIFEST);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_INVALID_MANIFEST);
             }
 
             // File is a jsbundle, move it to a folder with the packageHash as its name
@@ -403,7 +495,7 @@ public class CodePushUpdateManager {
         // Save metadata to the folder.
         CodePushUtils.writeJsonToFile(updatePackage, newUpdateMetadataPath);
 
-        return BinaryPatchResult.success();
+        return ArchiveRestoreResult.success();
     }
 
     public void installPackage(JSONObject updatePackage, boolean removePendingUpdate) {
@@ -452,6 +544,14 @@ public class CodePushUpdateManager {
         try {
             downloadUrl = new URL(remoteBundleUrl);
             connection = (HttpURLConnection) (downloadUrl.openConnection());
+            connection.setConnectTimeout(CodePushConstants.DOWNLOAD_CONNECT_TIMEOUT_IN_MS);
+            connection.setReadTimeout(CodePushConstants.DOWNLOAD_READ_TIMEOUT_IN_MS);
+
+            int responseCode = connection.getResponseCode();
+            if (responseCode >= 400) {
+                throw new CodePushHttpException(remoteBundleUrl, responseCode);
+            }
+
             bin = new BufferedInputStream(connection.getInputStream());
             File downloadFile = new File(getCurrentPackageBundlePath(bundleFileName));
             downloadFile.delete();