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

package/cli/commands/updateHistoryCommand/updateReleaseHistory.ts

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 
 export async function updateReleaseHistory(
     appVersion: string,
@@ -23,15 +22,8 @@ export async function updateReleaseHistory(
     if (typeof rollout === "number") updateInfo.rollout = rollout;
 
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier)
-
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) =>
+            setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     } catch (error) {
         console.error('Error occurred while updating history:', error);
         process.exit(1)

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function createReleaseHistory(targetVersion, setReleaseHistory, platform, identifier) {
     const BINARY_RELEASE = {
         enabled: true,
@@ -11,12 +10,7 @@ export async function createReleaseHistory(targetVersion, setReleaseHistory, pla
         [targetVersion]: BINARY_RELEASE
     };
     try {
-        const JSON_FILE_NAME = `${targetVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(INITIAL_HISTORY, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(INITIAL_HISTORY));
-        await setReleaseHistory(targetVersion, JSON_FILE_PATH, INITIAL_HISTORY, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(targetVersion, INITIAL_HISTORY, platform, (jsonFilePath) => setReleaseHistory(targetVersion, jsonFilePath, INITIAL_HISTORY, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while creating new history:', error);

package/cli/dist/commands/createHistoryCommand/createReleaseHistory.test.js

@@ -0,0 +1,95 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { createReleaseHistory } from "./createReleaseHistory.js";
+import { updateReleaseHistory } from "../updateHistoryCommand/updateReleaseHistory.js";
+/**
+ * Covers where the release history is staged before the config is handed it.
+ *
+ * The config receives a path rather than the history itself, so the command has to put the
+ * file somewhere first. Two releases of one app for different platforms are the same binary
+ * version, so a staging path derived from that version alone is the same path for both, and
+ * they overwrite each other's contents before either has read its own.
+ */
+const BINARY_VERSION = "1.0.0";
+let workingDir;
+let previousCwd;
+beforeEach(() => {
+    previousCwd = process.cwd();
+    workingDir = fs.mkdtempSync(path.join(os.tmpdir(), "codepush-history-staging-"));
+    process.chdir(workingDir);
+});
+afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(workingDir, { recursive: true, force: true });
+    jest.restoreAllMocks();
+});
+function stagedPath(platform) {
+    return path.join(workingDir, "codepush-release-history", platform, `${BINARY_VERSION}.json`);
+}
+/**
+ * Turns the command's own exit into a throw, so a staging failure fails the test instead
+ * of taking the worker down with it.
+ */
+function failOnExit() {
+    jest.spyOn(process, "exit").mockImplementation((code) => {
+        throw new Error(`the command exited with code ${String(code)}`);
+    });
+    jest.spyOn(console, "error").mockImplementation(() => undefined);
+    jest.spyOn(console, "log").mockImplementation(() => undefined);
+}
+describe("staging the release history a config is handed", () => {
+    it("gives each platform writing at the same time a file of its own", async () => {
+        failOnExit();
+        const staged = {};
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            // Yields once, which is all it takes for the other platform to reach its own
+            // write and its own clean-up while this one still holds only a path.
+            await Promise.resolve();
+            staged[platform] = { jsonFilePath, contents: fs.readFileSync(jsonFilePath, "utf8") };
+        };
+        await Promise.all([
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840"),
+            createReleaseHistory(BINARY_VERSION, setReleaseHistory, "android", "RN0840"),
+        ]);
+        expect(staged.ios.jsonFilePath).not.toBe(staged.android.jsonFilePath);
+    });
+    it("hands each platform the history that platform released", async () => {
+        failOnExit();
+        const released = {
+            ios: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "ios-url", packageHash: "ios-hash" } }),
+            android: JSON.stringify({ [BINARY_VERSION]: { enabled: true, mandatory: false, downloadUrl: "", packageHash: "" }, "1.0.1": { enabled: true, mandatory: true, downloadUrl: "android-url", packageHash: "android-hash" } }),
+        };
+        const staged = {};
+        const getReleaseHistory = async (_binaryVersion, platform) => JSON.parse(released[platform]);
+        const setReleaseHistory = async (_binaryVersion, jsonFilePath, _releaseInfo, platform) => {
+            await Promise.resolve();
+            staged[platform] = fs.readFileSync(jsonFilePath, "utf8");
+        };
+        await Promise.all([
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "ios", "RN0840", undefined, false, undefined),
+            updateReleaseHistory("1.0.1", BINARY_VERSION, getReleaseHistory, setReleaseHistory, "android", "RN0840", undefined, false, undefined),
+        ]);
+        expect(staged.ios).toContain("ios-url");
+        expect(staged.ios).not.toContain("android-url");
+        expect(staged.android).toContain("android-url");
+        expect(staged.android).not.toContain("ios-url");
+    });
+    it("takes the file away once the config has stored the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => undefined;
+        await createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840");
+        expect(fs.existsSync(stagedPath("ios"))).toBe(false);
+    });
+    it("leaves the file behind when the config could not store the history", async () => {
+        failOnExit();
+        const setReleaseHistory = async () => {
+            throw new Error("the storage backend rejected the history");
+        };
+        await expect(createReleaseHistory(BINARY_VERSION, setReleaseHistory, "ios", "RN0840")).rejects.toThrow("the command exited with code 1");
+        // What the release tried to store is worth reading back, so a failed release keeps
+        // its history at a path that is the same on every run.
+        expect(Object.keys(JSON.parse(fs.readFileSync(stagedPath("ios"), "utf8")))).toEqual([BINARY_VERSION]);
+    });
+});

package/cli/dist/commands/releaseCommand/addToReleaseHistory.js

@@ -1,5 +1,4 @@
-import path from "path";
-import fs from "fs";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout, diffPackages) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -28,12 +27,7 @@ export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownl
         newReleaseHistory[appVersion].rollout = rollout;
     }
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(newReleaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(newReleaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, newReleaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, newReleaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, newReleaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

package/cli/dist/commands/releaseCommand/release.test.js

@@ -119,9 +119,9 @@ beforeEach(() => {
 });
 afterEach(() => {
     jest.restoreAllMocks();
-    // addToReleaseHistory writes its JSON next to the invocation, and only removes it
-    // when the history was stored successfully.
-    fs.rmSync(path.resolve(process.cwd(), `${BINARY_VERSION}.json`), { force: true });
+    // addToReleaseHistory writes its JSON under the directory it was invoked in, and only
+    // removes it when the history was stored successfully.
+    fs.rmSync(path.resolve(process.cwd(), "codepush-release-history"), { recursive: true, force: true });
 });
 describe("release without --binary-bundle-path", () => {
     it("keeps existing three-argument uploaders callable", async () => {

package/cli/dist/commands/updateHistoryCommand/updateReleaseHistory.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import path from "path";
+import { stageReleaseHistoryFile } from "../../functions/stageReleaseHistoryFile.js";
 export async function updateReleaseHistory(appVersion, binaryVersion, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
@@ -12,12 +11,7 @@ export async function updateReleaseHistory(appVersion, binaryVersion, getRelease
     if (typeof rollout === "number")
         updateInfo.rollout = rollout;
     try {
-        const JSON_FILE_NAME = `${binaryVersion}.json`;
-        const JSON_FILE_PATH = path.resolve(process.cwd(), JSON_FILE_NAME);
-        console.log(`log: creating JSON file... ("${JSON_FILE_NAME}")\n`, JSON.stringify(releaseHistory, null, 2));
-        fs.writeFileSync(JSON_FILE_PATH, JSON.stringify(releaseHistory));
-        await setReleaseHistory(binaryVersion, JSON_FILE_PATH, releaseHistory, platform, identifier);
-        fs.unlinkSync(JSON_FILE_PATH);
+        await stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, (jsonFilePath) => setReleaseHistory(binaryVersion, jsonFilePath, releaseHistory, platform, identifier));
     }
     catch (error) {
         console.error('Error occurred while updating history:', error);

package/cli/dist/functions/stageReleaseHistoryFile.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import path from "path";
+const STAGING_DIR_NAME = 'codepush-release-history';
+/**
+ * Writes the release history to a file for the config to read, and takes it away again
+ * once the config has stored it.
+ *
+ * Written under a directory of the platform's own rather than straight into the directory
+ * the command ran in. The name follows from the binary version alone, so two commands
+ * releasing the same version of one app for different platforms shared one path: whichever
+ * finished first took the file away while the other was still about to read it, and before
+ * that each had overwritten the other's contents. The name itself is kept as it was,
+ * because the name is part of what the config is handed.
+ *
+ * A file whose history was never stored is left where it was written, so a release that
+ * failed can be read back from a path that is the same on every run.
+ */
+export async function stageReleaseHistoryFile(binaryVersion, releaseHistory, platform, store) {
+    const jsonFileName = `${binaryVersion}.json`;
+    const stagingDir = path.resolve(process.cwd(), STAGING_DIR_NAME, platform);
+    const jsonFilePath = path.join(stagingDir, jsonFileName);
+    fs.mkdirSync(stagingDir, { recursive: true });
+    console.log(`log: creating JSON file... ("${jsonFileName}")\n`, JSON.stringify(releaseHistory, null, 2));
+    fs.writeFileSync(jsonFilePath, JSON.stringify(releaseHistory));
+    const stored = await store(jsonFilePath);
+    fs.rmSync(jsonFilePath, { force: true });
+    return stored;
+}

package/cli/functions/stageReleaseHistoryFile.ts

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+import type { ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
+
+const STAGING_DIR_NAME = 'codepush-release-history';
+
+/**
+ * Writes the release history to a file for the config to read, and takes it away again
+ * once the config has stored it.
+ *
+ * Written under a directory of the platform's own rather than straight into the directory
+ * the command ran in. The name follows from the binary version alone, so two commands
+ * releasing the same version of one app for different platforms shared one path: whichever
+ * finished first took the file away while the other was still about to read it, and before
+ * that each had overwritten the other's contents. The name itself is kept as it was,
+ * because the name is part of what the config is handed.
+ *
+ * A file whose history was never stored is left where it was written, so a release that
+ * failed can be read back from a path that is the same on every run.
+ */
+export async function stageReleaseHistoryFile<T>(
+    binaryVersion: string,
+    releaseHistory: ReleaseHistoryInterface,
+    platform: 'ios' | 'android',
+    store: (jsonFilePath: string) => Promise<T>,
+): Promise<T> {
+    const jsonFileName = `${binaryVersion}.json`;
+    const stagingDir = path.resolve(process.cwd(), STAGING_DIR_NAME, platform);
+    const jsonFilePath = path.join(stagingDir, jsonFileName);
+
+    fs.mkdirSync(stagingDir, { recursive: true });
+    console.log(`log: creating JSON file... ("${jsonFileName}")\n`, JSON.stringify(releaseHistory, null, 2));
+    fs.writeFileSync(jsonFilePath, JSON.stringify(releaseHistory));
+
+    const stored = await store(jsonFilePath);
+    fs.rmSync(jsonFilePath, { force: true });
+    return stored;
+}

package/ios/CodePush/CodePush.h

@@ -157,22 +157,25 @@ failCallback:(void (^)(NSError *err))failCallback;
 @interface CodePushErrorUtils : NSObject
 
 + (NSError *)errorWithMessage:(NSString *)errorMessage;
++ (NSError *)errorWithMessage:(NSString *)errorMessage httpStatusCode:(NSInteger)statusCode;
 + (BOOL)isCodePushError:(NSError *)error;
++ (BOOL)isNetworkFailure:(NSError *)error;
++ (BOOL)isHttpStatusError:(NSError *)error;
 
 @end
 
 @interface CodePushPackage : NSObject
 
 /*
- * doneCallback is given what the attempt at installing the update from its binary patch
- * archive ended in, or nil when the update had no patch archive to attempt. The result
+ * doneCallback is given what the attempts at installing the update from its update
+ * archives ended in, or nil when the update had no archive to attempt. The result
  * describes the download and not the update: it is never part of the update's metadata.
  */
 + (void)downloadPackage:(NSDictionary *)updatePackage
  expectedBundleFileName:(NSString *)expectedBundleFileName
          operationQueue:(dispatch_queue_t)operationQueue
        progressCallback:(void (^)(long long, long long))progressCallback
-           doneCallback:(void (^)(NSDictionary *binaryPatchResult))doneCallback
+           doneCallback:(void (^)(NSDictionary *updateArchiveResult))doneCallback
            failCallback:(void (^)(NSError *err))failCallback;
 
 + (NSDictionary *)getCurrentPackage:(NSError **)error;

package/ios/CodePush/CodePush.mm

@@ -63,7 +63,7 @@ static NSString *const PackageIsPendingKey = @"isPending";
 
 // Not one of those keys: the field a download that tried a binary patch reports its outcome
 // under, on the package it resolves with and on no package it stores.
-static NSString *const BinaryPatchResultKey = @"binaryPatchResult";
+static NSString *const UpdateArchiveResultKey = @"updateArchiveResult";
 
 #pragma mark - Static variables
 
@@ -740,8 +740,8 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
         // The download is progressing forward
         progressCallback:^(long long expectedContentLength, long long receivedContentLength) {
             // Received bytes only run backwards when a new download starts a stream of its
-            // own - the full archive after a binary patch fallback. The pause left over
-            // from the finished patch download would swallow that whole stream, so frame
+            // own - the next archive after a binary patch fallback. The pause left over
+            // from the finished download would swallow that whole stream, so frame
             // observation resumes here and the throttle forgets the previous stream.
             if (notifyProgress && receivedContentLength < _latestReceivedConentLength) {
                 self.paused = NO;
@@ -767,21 +767,21 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
             }
         }
         // The download completed
-        doneCallback:^(NSDictionary *binaryPatchResult) {
+        doneCallback:^(NSDictionary *updateArchiveResult) {
             NSError *err;
             NSDictionary *newPackage = [CodePushPackage getPackage:mutableUpdatePackage[PackageHashKey] error:&err];
 
             if (err) {
-                return reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+                return reject([NSString stringWithFormat: @"%ld", (long)err.code], err.localizedDescription, err);
             }
 
-            if (binaryPatchResult) {
+            if (updateArchiveResult) {
                 // The result describes this download rather than the update, so it is put on
                 // what this call resolves with and nowhere else: the metadata that was
                 // written for the update knows nothing about it, and whoever asked for the
                 // download decides what the result is worth.
                 NSMutableDictionary *downloadedPackage = [newPackage mutableCopy];
-                downloadedPackage[BinaryPatchResultKey] = binaryPatchResult;
+                downloadedPackage[UpdateArchiveResultKey] = updateArchiveResult;
                 return resolve(downloadedPackage);
             }
 
@@ -796,7 +796,7 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
             // Stop observing frame updates if the download fails.
             _didUpdateProgress = NO;
             self.paused = YES;
-            reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+            reject([NSString stringWithFormat: @"%ld", (long)err.code], err.localizedDescription, err);
         }];
 }
 
@@ -876,7 +876,7 @@ RCT_EXPORT_METHOD(getUpdateMetadata:(double)updateStateValue
     NSMutableDictionary *package = [[CodePushPackage getCurrentPackage:&error] mutableCopy];
 
     if (error) {
-        return reject([NSString stringWithFormat: @"%lu", (long)error.code], error.localizedDescription, error);
+        return reject([NSString stringWithFormat: @"%ld", (long)error.code], error.localizedDescription, error);
     } else if (package == nil) {
         // The app hasn't downloaded any CodePush updates yet,
         // so we simply return nil regardless if the user
@@ -930,7 +930,7 @@ RCT_EXPORT_METHOD(installUpdate:(NSDictionary*)updatePackage
                               error:&error];
 
     if (error) {
-        reject([NSString stringWithFormat: @"%lu", (long)error.code], error.localizedDescription, error);
+        reject([NSString stringWithFormat: @"%ld", (long)error.code], error.localizedDescription, error);
     } else {
         [self savePendingUpdate:updatePackage[PackageHashKey]
                       isLoading:NO];

package/ios/CodePush/CodePushBinaryPatch.h

@@ -1,7 +1,7 @@
 #import <Foundation/Foundation.h>
 
 /*
- * Why an update that was downloaded as a binary patch has to be downloaded in full
+ * Why an update that was downloaded as one of its archives has to be downloaded in full
  * instead.
  *
  * A failed restore is not an error the user ever hears about: it is the signal to
@@ -11,22 +11,32 @@
  */
 
 /** The bundle inside the app binary could not be opened or read. */
-extern NSString *const CodePushBinaryPatchReasonBaseBundleUnavailable;
+extern NSString *const CodePushArchiveFallbackReasonBaseBundleUnavailable;
 
 /** The bundle inside the app binary is not the one the patch was computed against. */
-extern NSString *const CodePushBinaryPatchReasonBaseHashMismatch;
+extern NSString *const CodePushArchiveFallbackReasonBaseHashMismatch;
 
 /** The manifest is missing, malformed, points outside the archive, or asks for too much. */
-extern NSString *const CodePushBinaryPatchReasonInvalidManifest;
+extern NSString *const CodePushArchiveFallbackReasonInvalidManifest;
 
 /** The patch was produced by a format or a codec this client cannot apply. */
-extern NSString *const CodePushBinaryPatchReasonUnsupportedFormat;
+extern NSString *const CodePushArchiveFallbackReasonUnsupportedFormat;
 
 /** The applier refused the patch, or the restored bundle could not be written. */
-extern NSString *const CodePushBinaryPatchReasonPatchApplyFailed;
+extern NSString *const CodePushArchiveFallbackReasonPatchApplyFailed;
 
 /** The restored bundle is not the one the manifest promised. */
-extern NSString *const CodePushBinaryPatchReasonTargetVerificationFailed;
+extern NSString *const CodePushArchiveFallbackReasonTargetVerificationFailed;
+
+/**
+ * The asset diff could not be merged with the installed update it was built against.
+ *
+ * Reported by the caller too, from the merge that follows the restore: the diff archive
+ * only carries what the installed update does not, so this covers reading the installed
+ * update's files, applying the deletion manifest, and everything else that stitches the
+ * two back together.
+ */
+extern NSString *const CodePushArchiveFallbackReasonAssetMergeFailed;
 
 /**
  * The update restored from the patch did not pass the checks every update passes before
@@ -35,7 +45,7 @@ extern NSString *const CodePushBinaryPatchReasonTargetVerificationFailed;
  * This one is reported by the caller rather than by the applier: by the time it applies,
  * the applier has already handed back a bundle it was happy with.
  */
-extern NSString *const CodePushBinaryPatchReasonPackageVerificationFailed;
+extern NSString *const CodePushArchiveFallbackReasonPackageVerificationFailed;
 
 /**
  * Rebuilds the JS bundle of an update that was downloaded as a binary patch archive.

package/ios/CodePush/CodePushBinaryPatch.m

@@ -14,13 +14,14 @@
 #include "binarypatch_zstd_decompressor.h"
 #include "libHDiffPatch/HPatch/patch.h"
 
-NSString *const CodePushBinaryPatchReasonBaseBundleUnavailable = @"base_bundle_unavailable";
-NSString *const CodePushBinaryPatchReasonBaseHashMismatch = @"base_hash_mismatch";
-NSString *const CodePushBinaryPatchReasonInvalidManifest = @"invalid_manifest";
-NSString *const CodePushBinaryPatchReasonUnsupportedFormat = @"unsupported_format";
-NSString *const CodePushBinaryPatchReasonPatchApplyFailed = @"patch_apply_failed";
-NSString *const CodePushBinaryPatchReasonTargetVerificationFailed = @"target_verification_failed";
-NSString *const CodePushBinaryPatchReasonPackageVerificationFailed = @"package_verification_failed";
+NSString *const CodePushArchiveFallbackReasonBaseBundleUnavailable = @"base_bundle_unavailable";
+NSString *const CodePushArchiveFallbackReasonBaseHashMismatch = @"base_hash_mismatch";
+NSString *const CodePushArchiveFallbackReasonInvalidManifest = @"invalid_manifest";
+NSString *const CodePushArchiveFallbackReasonUnsupportedFormat = @"unsupported_format";
+NSString *const CodePushArchiveFallbackReasonPatchApplyFailed = @"patch_apply_failed";
+NSString *const CodePushArchiveFallbackReasonTargetVerificationFailed = @"target_verification_failed";
+NSString *const CodePushArchiveFallbackReasonAssetMergeFailed = @"asset_merge_failed";
+NSString *const CodePushArchiveFallbackReasonPackageVerificationFailed = @"package_verification_failed";
 
 #pragma mark - Private constants
 
@@ -205,7 +206,7 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
     NSString *contentsFolderPath = [self contentsFolderInUnzippedFolder:unzippedFolderPath];
     NSString *manifestFilePath = [contentsFolderPath stringByAppendingPathComponent:BinaryPatchManifestFileName];
     if (![self isFileAtPath:manifestFilePath]) {
-        return [self failWithReason:CodePushBinaryPatchReasonInvalidManifest
+        return [self failWithReason:CodePushArchiveFallbackReasonInvalidManifest
                    outFailureReason:failureReason];
     }
 
@@ -219,13 +220,13 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
                                : nil;
     if (![manifest isKindOfClass:[NSDictionary class]]) {
         CPLog(@"The binary patch manifest could not be read: %@", error);
-        return [self failWithReason:CodePushBinaryPatchReasonInvalidManifest
+        return [self failWithReason:CodePushArchiveFallbackReasonInvalidManifest
                    outFailureReason:failureReason];
     }
 
     if ([[self numberInManifest:manifest forKey:BinaryPatchFormatVersionKey] integerValue] != BinaryPatchFormatVersion
         || ![BinaryPatchAlgorithm isEqualToString:[self stringInManifest:manifest forKey:BinaryPatchAlgorithmKey]]) {
-        return [self failWithReason:CodePushBinaryPatchReasonUnsupportedFormat
+        return [self failWithReason:CodePushArchiveFallbackReasonUnsupportedFormat
                    outFailureReason:failureReason];
     }
 
@@ -239,7 +240,7 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
     if (targetBundleFilePath == nil || patchFilePath == nil || ![self isFileAtPath:patchFilePath]
         || baseBundleHash.length == 0 || targetBundleHash.length == 0
         || targetBundleSize <= 0 || targetBundleSize > BinaryPatchMaxTargetBundleSize) {
-        return [self failWithReason:CodePushBinaryPatchReasonInvalidManifest
+        return [self failWithReason:CodePushArchiveFallbackReasonInvalidManifest
                    outFailureReason:failureReason];
     }
 
@@ -250,7 +251,7 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
                                  attributes:nil
                                       error:&error]) {
         CPLog(@"Unable to create the binary patch working directory at %@: %@", workingFolderPath, error);
-        return [self failWithReason:CodePushBinaryPatchReasonPatchApplyFailed
+        return [self failWithReason:CodePushArchiveFallbackReasonPatchApplyFailed
                    outFailureReason:failureReason];
     }
 
@@ -296,13 +297,13 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
                                                               error:nil][NSFileSystemFreeSize];
     if (freeSize != nil && freeSize.longLongValue < targetBundleSize) {
         CPLog(@"Not enough free space to restore a %lld byte bundle.", targetBundleSize);
-        return CodePushBinaryPatchReasonPatchApplyFailed;
+        return CodePushArchiveFallbackReasonPatchApplyFailed;
     }
 
     NSString *baseBundlePath = [baseBundleURL path];
     if (baseBundlePath == nil) {
         CPLog(@"The app binary carries no JS bundle to patch against.");
-        return CodePushBinaryPatchReasonBaseBundleUnavailable;
+        return CodePushArchiveFallbackReasonBaseBundleUnavailable;
     }
 
     NSError *error = nil;
@@ -318,10 +319,10 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
                                                                                          error:&error];
     if (baseBundle == nil) {
         CPLog(@"Unable to read the JS bundle inside the app binary: %@", error);
-        return CodePushBinaryPatchReasonBaseBundleUnavailable;
+        return CodePushArchiveFallbackReasonBaseBundleUnavailable;
     }
     if (![baseBundleHash isEqualToString:[CodePushUpdateUtils computeHashForData:baseBundle]]) {
-        return CodePushBinaryPatchReasonBaseHashMismatch;
+        return CodePushArchiveFallbackReasonBaseHashMismatch;
     }
 
     __attribute__((objc_precise_lifetime)) NSData *patch = [NSData dataWithContentsOfFile:patchFilePath
@@ -329,7 +330,7 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
                                                                                    error:&error];
     if (patch == nil) {
         CPLog(@"Unable to read the binary patch: %@", error);
-        return CodePushBinaryPatchReasonPatchApplyFailed;
+        return CodePushArchiveFallbackReasonPatchApplyFailed;
     }
 
     NSString *restoredBundleFilePath = [workingFolderPath stringByAppendingPathComponent:BinaryPatchTargetFileName];
@@ -342,20 +343,20 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
     if (applyResult != CodePushBinaryPatchApplyResultOK) {
         CPLog(@"The binary patch applier returned %ld.", (long)applyResult);
         return applyResult == CodePushBinaryPatchApplyResultUnsupportedCompression
-            ? CodePushBinaryPatchReasonUnsupportedFormat
-            : CodePushBinaryPatchReasonPatchApplyFailed;
+            ? CodePushArchiveFallbackReasonUnsupportedFormat
+            : CodePushArchiveFallbackReasonPatchApplyFailed;
     }
 
     NSDictionary *restoredBundleAttributes = [fileManager attributesOfItemAtPath:restoredBundleFilePath
                                                                            error:&error];
     if (restoredBundleAttributes == nil || (long long)[restoredBundleAttributes fileSize] != targetBundleSize) {
         CPLog(@"The restored bundle is not %lld bytes long: %@", targetBundleSize, error);
-        return CodePushBinaryPatchReasonTargetVerificationFailed;
+        return CodePushArchiveFallbackReasonTargetVerificationFailed;
     }
 
     NSString *restoredBundleHash = [CodePushUpdateUtils computeHashForFileAtPath:restoredBundleFilePath];
     if (restoredBundleHash == nil || ![targetBundleHash isEqualToString:restoredBundleHash]) {
-        return CodePushBinaryPatchReasonTargetVerificationFailed;
+        return CodePushArchiveFallbackReasonTargetVerificationFailed;
     }
 
     if (![self moveItemAtPath:restoredBundleFilePath toPath:targetBundleFilePath]
@@ -365,7 +366,7 @@ static CodePushBinaryPatchApplyResult CodePushApplyBinaryPatch(const unsigned ch
         // that follows empties the unzipped archive before it replaces it, which is what
         // clears them.
         CPLog(@"Unable to put the restored bundle in place of the patch: %@", error);
-        return CodePushBinaryPatchReasonPatchApplyFailed;
+        return CodePushArchiveFallbackReasonPatchApplyFailed;
     }
 
     return nil;

package/ios/CodePush/CodePushDownloadHandler.m

@@ -54,7 +54,8 @@ failCallback:(void (^)(NSError *err))failCallback {
         if (statusCode >= 400) {
             [self.outputFileStream close];
             [connection cancel];
-            NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat: @"Received %ld response from %@", (long)statusCode, self.downloadUrl]];
+            NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat: @"Received %ld response from %@", (long)statusCode, self.downloadUrl]
+                                                 httpStatusCode:statusCode];
             self.failCallback(err);
             return;
         }

package/ios/CodePush/CodePushErrorUtils.m

@@ -4,6 +4,13 @@
 
 static NSString *const CodePushErrorDomain = @"CodePushError";
 static const int CodePushErrorCode = -1;
+/*
+ * The status a server answered a download with, on the error raised for it.
+ *
+ * Carried in the user info rather than in the error code, because the code is what JS reads
+ * an error by and every error of this domain has always been -1 there.
+ */
+static NSString *const CodePushHttpStatusCodeKey = @"CodePushHttpStatusCode";
 
 + (NSError *)errorWithMessage:(NSString *)errorMessage
 {
@@ -12,9 +19,57 @@ static const int CodePushErrorCode = -1;
                            userInfo:@{ NSLocalizedDescriptionKey: NSLocalizedString(errorMessage, nil) }];
 }
 
++ (NSError *)errorWithMessage:(NSString *)errorMessage httpStatusCode:(NSInteger)statusCode
+{
+    return [NSError errorWithDomain:CodePushErrorDomain
+                               code:CodePushErrorCode
+                           userInfo:@{ NSLocalizedDescriptionKey: NSLocalizedString(errorMessage, nil),
+                                       CodePushHttpStatusCodeKey: @(statusCode) }];
+}
+
 + (BOOL)isCodePushError:(NSError *)err
 {
     return err != nil && [CodePushErrorDomain isEqualToString:err.domain];
 }
 
+/*
+ * Whether the download failed because the server answered it with a status rather than with
+ * a body to install.
+ */
++ (BOOL)isHttpStatusError:(NSError *)err
+{
+    return [self isCodePushError:err] && err.userInfo[CodePushHttpStatusCodeKey] != nil;
+}
+
+/*
+ * Whether the request 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.
+ *
+ * Named from the codes rather than the domain, because `NSURLErrorDomain` also covers a
+ * URL that was malformed or a scheme that is not supported - failures of the request
+ * rather than of the network under it.
+ */
++ (BOOL)isNetworkFailure:(NSError *)err
+{
+    if (err == nil || ![NSURLErrorDomain isEqualToString:err.domain]) {
+        return NO;
+    }
+
+    switch (err.code) {
+        case NSURLErrorTimedOut:
+        case NSURLErrorCannotFindHost:
+        case NSURLErrorCannotConnectToHost:
+        case NSURLErrorNetworkConnectionLost:
+        case NSURLErrorDNSLookupFailed:
+        case NSURLErrorNotConnectedToInternet:
+        case NSURLErrorSecureConnectionFailed:
+            return YES;
+        default:
+            return NO;
+    }
+}
+
 @end