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

package/cli/dist/functions/resolveAssetDiffBases.test.js

@@ -13,6 +13,7 @@ import { resolveAssetDiffBases } from "./resolveAssetDiffBases.js";
 const CONTENTS_DIR_NAME = 'CodePush';
 /** Where the resolver unpacks a base for verification, so leftovers are recognizable. */
 const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
+const TARGET_BINARY_VERSION = '1.0.0';
 let workDir;
 let bundleDirectory;
 /** Releases one full archive the way the CLI does, and returns what the history records. */
@@ -49,16 +50,16 @@ function releaseHistoryOf(releases) {
 /** Stands in for the consumer's downloader: hands back a local archive per download url. */
 function fakeDownloader(archives) {
     const calls = [];
-    const download = async (downloadUrl, platform, identifier) => {
-        calls.push([downloadUrl, platform, identifier]);
-        const archive = archives[downloadUrl];
-        if (archive instanceof Error) {
-            throw archive;
+    const download = async (downloadInfo, platform, identifier) => {
+        calls.push([downloadInfo, platform, identifier]);
+        const downloadedArchive = archives[downloadInfo.downloadUrl];
+        if (downloadedArchive instanceof Error) {
+            throw downloadedArchive;
         }
-        if (!archive) {
-            throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+        if (!downloadedArchive) {
+            throw new Error(`the downloader was called with an unexpected url: ${downloadInfo.downloadUrl}`);
         }
-        return { downloadedFilePath: archive };
+        return { downloadedFilePath: downloadedArchive };
     };
     return { download, calls };
 }
@@ -86,14 +87,15 @@ describe("resolveAssetDiffBases", () => {
             bundleDownloader: download,
             platform: 'android',
             identifier: 'my-app',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: newest.packageHash, baseBundleFilePath: newest.archivePath },
             { basePackageHash: second.packageHash, baseBundleFilePath: second.archivePath },
         ]);
         expect(calls).toEqual([
-            [newest.downloadUrl, 'android', 'my-app'],
-            [second.downloadUrl, 'android', 'my-app'],
+            [{ downloadUrl: newest.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: newest.version, packageHash: newest.packageHash }, 'android', 'my-app'],
+            [{ downloadUrl: second.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: second.version, packageHash: second.packageHash }, 'android', 'my-app'],
         ]);
     });
     it("skips history entries that lack a download url or a package hash", async () => {
@@ -109,11 +111,16 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 1,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+                { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+                'ios',
+                undefined,
+            ]]);
     });
     it("ignores a history entry whose key is not a version, and resolves the rest", async () => {
         const [released] = await stageReleases(['1.4.0']);
@@ -131,11 +138,16 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+                { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+                'ios',
+                undefined,
+            ]]);
     });
     it("drops a base whose downloaded bytes do not match its recorded package hash", async () => {
         const [older, newer] = await stageReleases(['1.2.0', '1.2.1']);
@@ -150,6 +162,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
         expect(warn.mock.calls.join('\n')).toMatch(/1\.2\.1/);
@@ -167,6 +180,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
         expect(warn.mock.calls.join('\n')).toMatch(/1\.3\.1.*the network is down/s);

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/resolveAssetDiffBases.test.ts

@@ -4,7 +4,7 @@ import path from "path";
 import { afterAll, afterEach, beforeAll, describe, expect, it, jest } from "@jest/globals";
 import { makeCodePushBundle } from "./makeCodePushBundle.js";
 import { resolveAssetDiffBases } from "./resolveAssetDiffBases.js";
-import type { CliConfigInterface, ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
+import type { BundleDownloadInfo, CliConfigInterface, ReleaseHistoryInterface } from "../../typings/react-native-code-push.d.ts";
 
 /**
  * Exercises base acquisition against real archives and real hashes: a base is only usable
@@ -17,6 +17,7 @@ const CONTENTS_DIR_NAME = 'CodePush';
 
 /** Where the resolver unpacks a base for verification, so leftovers are recognizable. */
 const TEMP_DIR_PREFIX = 'codepush-asset-diff-base-';
+const TARGET_BINARY_VERSION = '1.0.0';
 
 type StagedRelease = {
     version: string;
@@ -68,22 +69,22 @@ function releaseHistoryOf(releases: StagedRelease[]): ReleaseHistoryInterface {
 
 /** Stands in for the consumer's downloader: hands back a local archive per download url. */
 function fakeDownloader(archives: Record<string, string | Error>) {
-    const calls: Array<[string, string, string | undefined]> = [];
+    const calls: Array<[BundleDownloadInfo, string, string | undefined]> = [];
     const download: NonNullable<CliConfigInterface['bundleDownloader']> = async (
-        downloadUrl,
+        downloadInfo,
         platform,
         identifier,
     ) => {
-        calls.push([downloadUrl, platform, identifier]);
+        calls.push([downloadInfo, platform, identifier]);
 
-        const archive = archives[downloadUrl];
-        if (archive instanceof Error) {
-            throw archive;
+        const downloadedArchive = archives[downloadInfo.downloadUrl];
+        if (downloadedArchive instanceof Error) {
+            throw downloadedArchive;
         }
-        if (!archive) {
-            throw new Error(`the downloader was called with an unexpected url: ${downloadUrl}`);
+        if (!downloadedArchive) {
+            throw new Error(`the downloader was called with an unexpected url: ${downloadInfo.downloadUrl}`);
         }
-        return { downloadedFilePath: archive };
+        return { downloadedFilePath: downloadedArchive };
     };
     return { download, calls };
 }
@@ -119,6 +120,7 @@ describe("resolveAssetDiffBases", () => {
             bundleDownloader: download,
             platform: 'android',
             identifier: 'my-app',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
@@ -126,8 +128,8 @@ describe("resolveAssetDiffBases", () => {
             { basePackageHash: second.packageHash, baseBundleFilePath: second.archivePath },
         ]);
         expect(calls).toEqual([
-            [newest.downloadUrl, 'android', 'my-app'],
-            [second.downloadUrl, 'android', 'my-app'],
+            [{ downloadUrl: newest.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: newest.version, packageHash: newest.packageHash }, 'android', 'my-app'],
+            [{ downloadUrl: second.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: second.version, packageHash: second.packageHash }, 'android', 'my-app'],
         ]);
     });
 
@@ -145,12 +147,17 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 1,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+            { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+            'ios',
+            undefined,
+        ]]);
     });
 
     it("ignores a history entry whose key is not a version, and resolves the rest", async () => {
@@ -170,12 +177,17 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'ios',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([
             { basePackageHash: released.packageHash, baseBundleFilePath: released.archivePath },
         ]);
-        expect(calls).toEqual([[released.downloadUrl, 'ios', undefined]]);
+        expect(calls).toEqual([[
+            { downloadUrl: released.downloadUrl, targetBinaryVersion: TARGET_BINARY_VERSION, releaseVersion: released.version, packageHash: released.packageHash },
+            'ios',
+            undefined,
+        ]]);
     });
 
     it("drops a base whose downloaded bytes do not match its recorded package hash", async () => {
@@ -192,6 +204,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);
@@ -212,6 +225,7 @@ describe("resolveAssetDiffBases", () => {
             diffBaseCount: 2,
             bundleDownloader: download,
             platform: 'android',
+            targetBinaryVersion: TARGET_BINARY_VERSION,
         });
 
         expect(bases).toEqual([{ basePackageHash: older.packageHash, baseBundleFilePath: older.archivePath }]);

package/cli/functions/resolveAssetDiffBases.ts

@@ -40,12 +40,14 @@ export async function resolveAssetDiffBases({
     bundleDownloader,
     platform,
     identifier,
+    targetBinaryVersion,
 }: {
     releaseHistory: ReleaseHistoryInterface;
     diffBaseCount: number;
     bundleDownloader: NonNullable<CliConfigInterface['bundleDownloader']>;
     platform: 'ios' | 'android';
     identifier?: string;
+    targetBinaryVersion: string;
 }): Promise<AssetDiffBase[]> {
     // The seeded entry for the update inside the app binary has neither a url nor a hash,
     // and nothing can be diffed against a package that was never published. A key that is
@@ -60,7 +62,12 @@ export async function resolveAssetDiffBases({
     const bases: AssetDiffBase[] = [];
     for (const [version, releaseInfo] of candidates) {
         try {
-            const { downloadedFilePath } = await bundleDownloader(releaseInfo.downloadUrl, platform, identifier);
+            const { downloadedFilePath } = await bundleDownloader({
+                downloadUrl: releaseInfo.downloadUrl,
+                targetBinaryVersion,
+                releaseVersion: version,
+                packageHash: releaseInfo.packageHash,
+            }, platform, identifier);
 
             if (!(await matchesPackageHash(downloadedFilePath, releaseInfo.packageHash))) {
                 console.warn(

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;
         }