react-native-update 10.49.0 → 10.51.0

package/android/src/main/java/cn/reactnative/modules/update/DownloadTask.java

@@ -77,6 +77,9 @@ class DownloadTask implements Runnable {
     private final byte[] buffer = new byte[DOWNLOAD_CHUNK_SIZE];
     private final BundledResourceCopier bundledResourceCopier;
     private String hash;
+    // Set once downloadFile() returns: failures after this point in a patch
+    // task are patch-application failures, not download failures.
+    private boolean downloadPhaseCompleted = false;
 
     DownloadTask(Context context, DownloadTaskParams params) {
         this.context = context.getApplicationContext();
@@ -104,14 +107,29 @@ class DownloadTask implements Runnable {
         this.hash = params.hash;
         String url = params.url;
         File writePath = params.targetFile;
-        UpdateFileUtils.ensureParentDirectory(writePath);
         Request request = new Request.Builder().url(url).build();
 
+        OkHttpClient requestClient = HTTP_CLIENT;
+        if (params.deadlineNanos > 0) {
+            long remainingNanos = params.deadlineNanos - System.nanoTime();
+            if (remainingNanos <= 0) {
+                throw new IOException("Download deadline expired before start");
+            }
+            long remainingMillis = Math.max(
+                1L,
+                java.util.concurrent.TimeUnit.NANOSECONDS.toMillis(remainingNanos)
+            );
+            requestClient = HTTP_CLIENT.newBuilder()
+                .callTimeout(remainingMillis, java.util.concurrent.TimeUnit.MILLISECONDS)
+                .build();
+        }
+
+        UpdateFileUtils.ensureParentDirectory(writePath);
         if (writePath.exists() && !writePath.delete()) {
             throw new IOException("Failed to replace existing file: " + writePath);
         }
 
-        try (Response response = HTTP_CLIENT.newCall(request).execute()) {
+        try (Response response = requestClient.newCall(request).execute()) {
             if (!response.isSuccessful()) {
                 throw new IOException("Server error: " + response.code() + " " + response.message());
             }
@@ -160,6 +178,7 @@ class DownloadTask implements Runnable {
             }
         }
 
+        downloadPhaseCompleted = true;
     }
 
     private byte[] readBytes(InputStream input) throws IOException {
@@ -408,39 +427,96 @@ class DownloadTask implements Runnable {
         }
     }
 
+    private boolean isPatchTask(int taskType) {
+        return taskType == DownloadTaskParams.TASK_TYPE_PATCH_FULL
+            || taskType == DownloadTaskParams.TASK_TYPE_PATCH_FROM_APK
+            || taskType == DownloadTaskParams.TASK_TYPE_PATCH_FROM_PPK;
+    }
+
+    private boolean hasCompletedPatchDirectory() {
+        return params.unzipDirectory != null
+            && new File(params.unzipDirectory, "index.bundlejs").isFile()
+            && new File(
+                params.unzipDirectory,
+                UpdateContext.VERSION_COMPLETE_FILE
+            ).isFile();
+    }
+
     @Override
     public void run() {
         int taskType = params.type;
+        final boolean alreadyCompleted = isPatchTask(taskType)
+            && hasCompletedPatchDirectory();
         try {
-            switch (taskType) {
-                case DownloadTaskParams.TASK_TYPE_PATCH_FULL:
-                    doFullPatch();
-                    break;
-                case DownloadTaskParams.TASK_TYPE_PATCH_FROM_APK:
-                    doPatchFromApk();
-                    break;
-                case DownloadTaskParams.TASK_TYPE_PATCH_FROM_PPK:
-                    doPatchFromPpk();
-                    break;
-                case DownloadTaskParams.TASK_TYPE_CLEANUP:
-                    doCleanUp();
-                    break;
-                case DownloadTaskParams.TASK_TYPE_PLAIN_DOWNLOAD:
-                    downloadFile();
-                    break;
-                default:
-                    break;
+            if (alreadyCompleted) {
+                Log.i(UpdateContext.TAG,
+                    "download task: version " + params.hash + " already completed");
+            } else {
+                switch (taskType) {
+                    case DownloadTaskParams.TASK_TYPE_PATCH_FULL:
+                        doFullPatch();
+                        break;
+                    case DownloadTaskParams.TASK_TYPE_PATCH_FROM_APK:
+                        doPatchFromApk();
+                        break;
+                    case DownloadTaskParams.TASK_TYPE_PATCH_FROM_PPK:
+                        doPatchFromPpk();
+                        break;
+                    case DownloadTaskParams.TASK_TYPE_CLEANUP:
+                        doCleanUp();
+                        break;
+                    case DownloadTaskParams.TASK_TYPE_PLAIN_DOWNLOAD:
+                        downloadFile();
+                        break;
+                    default:
+                        break;
+                }
             }
         } catch (Throwable error) {
             Log.e(UpdateContext.TAG, "download task failed", error);
-            cleanUpAfterFailure(taskType);
+            // A duplicate task must never delete a version completed by an
+            // earlier queued task. The marker + bundle pair is the ownership
+            // handoff: once present, this failure did not create that install.
+            if (!hasCompletedPatchDirectory()) {
+                cleanUpAfterFailure(taskType);
+            }
 
             if (params.listener != null) {
-                params.listener.onDownloadFailed(error);
+                // A patch task that failed after its artifact was fully
+                // downloaded (unzip / hdiff / resource copy, incl. copiesCrc
+                // verification) is a patch failure, not a download failure —
+                // the module maps the exception type to PATCH_FAILED.
+                Throwable classified = error;
+                if (downloadPhaseCompleted
+                    && isPatchTask(taskType)
+                    && !(error instanceof PatchFailedException)) {
+                    classified = new PatchFailedException(
+                        String.valueOf(error.getMessage()), error);
+                }
+                params.listener.onDownloadFailed(classified);
             }
             return;
         }
 
+        if (isPatchTask(taskType) && !alreadyCompleted) {
+            try {
+                File marker = new File(
+                    params.unzipDirectory,
+                    UpdateContext.VERSION_COMPLETE_FILE
+                );
+                if (!marker.createNewFile() && !marker.isFile()) {
+                    throw new IOException("Failed to mark completed update: " + marker);
+                }
+            } catch (Throwable error) {
+                Log.e(UpdateContext.TAG, "failed to mark completed update", error);
+                cleanUpAfterFailure(taskType);
+                if (params.listener != null) {
+                    params.listener.onDownloadFailed(error);
+                }
+                return;
+            }
+        }
+
         // The task itself succeeded. Run the completion callback outside the
         // try/catch above so an exception thrown by the callback (e.g. a
         // FileProvider misconfiguration during installApk) is not mistaken for

package/android/src/main/java/cn/reactnative/modules/update/DownloadTaskParams.java

@@ -20,6 +20,9 @@ class DownloadTaskParams {
     String      originHash;
     // TASK_TYPE_CLEANUP only: entries younger than this survive; 0 = delete all
     int         maxAgeDays = 3;
+    // Absolute System.nanoTime deadline for orchestrated cold-start downloads;
+    // 0 keeps the normal public API's 10-minute per-call timeout.
+    long        deadlineNanos;
     File        targetFile;
     File        unzipDirectory;
     File        originDirectory;

package/android/src/main/java/cn/reactnative/modules/update/NativeCheckOrchestrator.java

@@ -0,0 +1,455 @@
+package cn.reactnative.modules.update;
+
+import android.os.Build;
+import android.util.Log;
+import java.util.HashSet;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Native cold-start update check (NATIVE_CHECKUPDATE_DESIGN §10): once per
+ * process, a few seconds after getBundleUrl, entirely independent of the app
+ * bundle — this is what lets a device bricked by a bad hot update pull the
+ * fixed version on the next launch. All decisions come from
+ * cpp/update_flow_core via NativeUpdateFlow; this class is IO glue only.
+ * Failures are silent and bounded: one round per launch, no retry storms, no
+ * version blacklisting.
+ */
+final class NativeCheckOrchestrator {
+    static final String KEY_CONFIG = "nativeConfig";
+    // Raw response cache for the JS side to reuse (§10.3), scoped to the
+    // exact logical request and native config that produced it.
+    static final String KEY_RESP_CACHE = "nativeCheckResp";
+    private static final int MAX_CHECK_HTTP_ATTEMPTS = 8;
+    private static final long DOWNLOAD_PHASE_TIMEOUT_SECONDS = 600;
+
+    private static final AtomicBoolean scheduled = new AtomicBoolean(false);
+
+    private NativeCheckOrchestrator() {
+    }
+
+    static void schedule(final UpdateContext context, final String launchRolledBackVersion) {
+        if (UpdateContext.DEBUG) {
+            return;
+        }
+        if (!scheduled.compareAndSet(false, true)) {
+            return;
+        }
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    // Keep the check away from the cold-start critical path
+                    // (§7 R5) — its result targets the NEXT launch anyway.
+                    Thread.sleep(5000);
+                    runOnce(context, launchRolledBackVersion);
+                } catch (Throwable e) {
+                    // The rescue path must never take the app down with it.
+                    Log.w(UpdateContext.TAG, "native check failed: " + e);
+                }
+            }
+        }, "pushy-native-check");
+        thread.setPriority(Thread.MIN_PRIORITY + 1);
+        thread.setDaemon(true);
+        thread.start();
+    }
+
+    private static void runOnce(
+        UpdateContext context,
+        String launchRolledBackVersion
+    ) throws JSONException {
+        // Sampled before any IO: a reset landing while this round runs must
+        // win over the round's decision.
+        final long resetGeneration = UpdateContext.getResetGeneration();
+        String configJson = context.getKv(KEY_CONFIG);
+        if (configJson == null || configJson.isEmpty()) {
+            // No persisted config (old integration / first ever launch): the
+            // native check silently does not run — this is the rollout gate.
+            return;
+        }
+        JSONObject config;
+        try {
+            config = new JSONObject(configJson);
+        } catch (JSONException e) {
+            return;
+        }
+        if (config.optBoolean("disabled", false)) {
+            return;
+        }
+        String appKey = config.optString("appKey", "");
+        if (appKey.isEmpty()) {
+            return;
+        }
+        String packageVersion = config.optString(
+            "packageVersion", context.getPackageVersion());
+        if (packageVersion.isEmpty()) {
+            packageVersion = context.getPackageVersion();
+        }
+
+        String currentVersion = context.getCurrentVersion();
+        // Snapshot captured on the launch path before getConstants consumes
+        // the one-shot rollback marker. Reading SharedPreferences here, five
+        // seconds later, would lose the guard and could forceBoot the version
+        // that this very launch just rolled back.
+        String rolledBackVersion = launchRolledBackVersion;
+        String uuid = context.getKv("uuid");
+        if (uuid == null) {
+            uuid = "";
+        }
+
+        JSONObject identity = new JSONObject();
+        identity.put("packageVersion", packageVersion);
+        identity.put(
+            "currentVersion",
+            currentVersion == null ? JSONObject.NULL : currentVersion
+        );
+        identity.put("uuid", uuid);
+        if (rolledBackVersion != null) {
+            identity.put("rolledBackVersion", rolledBackVersion);
+        }
+
+        JSONObject cInfo = new JSONObject();
+        cInfo.put("rnu", config.optString("rnu", ""));
+        cInfo.put("rn", config.optString("rn", ""));
+        // React Native's Platform.Version is the Android SDK integer; use the
+        // same value so this request can be fingerprinted against the JS one.
+        cInfo.put("os", "android " + Build.VERSION.SDK_INT);
+        cInfo.put("uuid", uuid);
+
+        JSONObject input = new JSONObject();
+        input.put("packageVersion", packageVersion);
+        input.put(
+            "currentVersion",
+            currentVersion == null ? JSONObject.NULL : currentVersion
+        );
+        input.put("buildTime", context.getBuildTime());
+        input.put("cInfo", cInfo);
+        input.put("supportedDiffVersion", NativeUpdateCore.supportedDiffVersion());
+        input.put("bundleHash", context.computeBundleHash());
+
+        String body = NativeUpdateFlow.buildCheckRequestBody(input.toString());
+        if (body == null) {
+            return;
+        }
+
+        String responseText = runCheckRequest(config, appKey, body);
+        if (responseText == null) {
+            Log.i(UpdateContext.TAG,
+                "native check: no endpoint reachable, giving up until next launch");
+            return;
+        }
+        // Cache freshness is anchored to when the server response arrived,
+        // not to when a potentially long download/patch/activation finished.
+        final long responseAtSeconds = System.currentTimeMillis() / 1000;
+
+        String decisionJson = NativeUpdateFlow.handleCheckResponse(
+            responseText, identity.toString(), config.optString("afterDownload", ""));
+        if (decisionJson == null) {
+            return;
+        }
+        JSONObject decision = new JSONObject(decisionJson);
+        if (!"download".equals(decision.optString("action"))) {
+            context.commitNativeCheckResult(
+                resetGeneration, null, null, false,
+                buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
+            Log.i(UpdateContext.TAG,
+                "native check: nothing to do (" + decision.optString("reason") + ")");
+            return;
+        }
+        String hash = decision.optString("hash", "");
+        if (!UpdateContext.isSafePathComponent(hash)) {
+            return;
+        }
+
+        boolean downloaded = context.hasCompletedVersion(hash);
+        if (!downloaded) {
+            downloaded = performAttempts(
+                context, decision.optJSONArray("attempts"), hash, currentVersion);
+        }
+        if (!downloaded) {
+            // The native attempt has finished, so JS may safely reuse the
+            // response and retry through its own strategy chain.
+            context.commitNativeCheckResult(
+                resetGeneration, null, null, false,
+                buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
+            return;
+        }
+
+        // Version info (mirroring the JS side's setLocalHashInfo), the
+        // activation and the response cache all land in one atomic commit —
+        // see UpdateContext.commitNativeCheckResult.
+        String hashInfoJson = null;
+        JSONObject info = decision.optJSONObject("info");
+        if (info != null) {
+            JSONObject hashInfo = new JSONObject();
+            for (String key : new String[] {"name", "description", "metaInfo"}) {
+                Object value = info.opt(key);
+                if (value instanceof String) {
+                    hashInfo.put(key, value);
+                }
+            }
+            hashInfoJson = hashInfo.toString();
+        }
+        // Silent strategies or a server-marked forceBoot version (per-version
+        // remote override — the brick rescue) activate for the next launch;
+        // otherwise activation stays with the JS side.
+        boolean activate = decision.optBoolean("activate", false);
+        boolean committed;
+        try {
+            committed = context.commitNativeCheckResult(
+                resetGeneration,
+                hash,
+                hashInfoJson,
+                activate,
+                buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
+        } catch (Exception e) {
+            Log.w(UpdateContext.TAG, "native check: commit failed: " + e);
+            return;
+        }
+        if (!committed) {
+            Log.i(UpdateContext.TAG, "native check: reset during round, dropping result");
+        } else if (activate) {
+            Log.i(UpdateContext.TAG,
+                "native check: downloaded " + hash + " and set for next launch");
+        } else {
+            Log.i(UpdateContext.TAG,
+                "native check: downloaded " + hash + ", activation left to JS");
+        }
+    }
+
+    private static String buildResponseCacheJson(
+        String configJson,
+        String requestBody,
+        String responseText,
+        long responseAtSeconds
+    ) throws JSONException {
+        JSONObject cacheEntry = new JSONObject();
+        cacheEntry.put("ts", responseAtSeconds);
+        cacheEntry.put("body", responseText);
+        cacheEntry.put("request", requestBody);
+        cacheEntry.put("config", configJson);
+        return cacheEntry.toString();
+    }
+
+    private static final OkHttpClient httpClient = new OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(10, TimeUnit.SECONDS)
+        .callTimeout(15, TimeUnit.SECONDS)
+        .build();
+
+    private static String httpRequest(String url, String postBody) {
+        try {
+            Request.Builder builder =
+                new Request.Builder().url(url).header("Accept", "application/json");
+            if (postBody != null) {
+                builder.post(RequestBody.create(
+                    postBody, MediaType.parse("application/json; charset=utf-8")));
+            }
+            try (Response response = httpClient.newCall(builder.build()).execute()) {
+                if (!response.isSuccessful() || response.body() == null) {
+                    return null;
+                }
+                return response.body().string();
+            }
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static boolean isValidCheckResponse(String responseText) {
+        if (responseText == null) {
+            return false;
+        }
+        try {
+            new JSONObject(responseText);
+            return true;
+        } catch (JSONException e) {
+            return false;
+        }
+    }
+
+    private static String normalizeEndpointBase(String base) {
+        while (base.endsWith("/")) {
+            base = base.substring(0, base.length() - 1);
+        }
+        return base;
+    }
+
+    /**
+     * Sequential fallback over the ordered candidates (§5.1): one request at
+     * a time with its own timeout; after the configured round fails,
+     * queryUrls discovery merges remote candidates (excluding the
+     * already-tried) for one more round. No hedged race on purpose — this
+     * path is latency-insensitive.
+     */
+    private static String runCheckRequest(JSONObject config, String appKey, String body) {
+        JSONArray endpoints = config.optJSONArray("endpoints");
+        String orderedJson = NativeUpdateFlow.orderEndpointCandidates(
+            endpoints == null ? "[]" : endpoints.toString(), Math.random());
+        JSONArray ordered;
+        try {
+            ordered = orderedJson == null ? new JSONArray() : new JSONArray(orderedJson);
+        } catch (JSONException e) {
+            return null;
+        }
+        HashSet<String> tried = new HashSet<>();
+        int httpAttempts = 0;
+        for (int i = 0; i < ordered.length(); i++) {
+            String base = normalizeEndpointBase(ordered.optString(i, ""));
+            if (base.isEmpty() || !tried.add(base)) {
+                continue;
+            }
+            if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+                return null;
+            }
+            String response = httpRequest(base + "/checkUpdate/" + appKey, body);
+            if (isValidCheckResponse(response)) {
+                return response;
+            }
+        }
+        JSONArray queryUrls = config.optJSONArray("queryUrls");
+        if (queryUrls == null) {
+            return null;
+        }
+        for (int i = 0; i < queryUrls.length(); i++) {
+            String listUrl = queryUrls.optString(i, "");
+            if (listUrl.isEmpty()) {
+                continue;
+            }
+            if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+                return null;
+            }
+            String listText = httpRequest(listUrl, null);
+            if (listText == null) {
+                continue;
+            }
+            JSONArray remote;
+            try {
+                remote = new JSONArray(listText);
+            } catch (JSONException e) {
+                continue;
+            }
+            for (int j = 0; j < remote.length(); j++) {
+                String base = normalizeEndpointBase(remote.optString(j, ""));
+                if (base.isEmpty() || tried.contains(base)) {
+                    continue;
+                }
+                if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+                    return null;
+                }
+                tried.add(base);
+                String response = httpRequest(base + "/checkUpdate/" + appKey, body);
+                if (isValidCheckResponse(response)) {
+                    return response;
+                }
+            }
+            // One successfully fetched remote list is enough.
+            break;
+        }
+        return null;
+    }
+
+    private static boolean performAttempts(
+        UpdateContext context, JSONArray attempts, String hash, String originHash
+    ) {
+        if (attempts == null) {
+            return false;
+        }
+        final long incrementalDeadlineNanos = System.nanoTime()
+            + TimeUnit.SECONDS.toNanos(DOWNLOAD_PHASE_TIMEOUT_SECONDS);
+        long fullDeadlineNanos = 0;
+        for (int i = 0; i < attempts.length(); i++) {
+            JSONObject attempt = attempts.optJSONObject(i);
+            if (attempt == null) {
+                continue;
+            }
+            String type = attempt.optString("type");
+            if ("diff".equals(type) && (originHash == null || originHash.isEmpty())) {
+                // diff patches from the running version; none is running.
+                continue;
+            }
+            final boolean isFullAttempt = !"diff".equals(type) && !"pdiff".equals(type);
+            if (isFullAttempt && fullDeadlineNanos == 0) {
+                // Incremental failures must not consume the last-resort full
+                // download's budget. Each phase gets one bounded 10min window.
+                fullDeadlineNanos = System.nanoTime()
+                    + TimeUnit.SECONDS.toNanos(DOWNLOAD_PHASE_TIMEOUT_SECONDS);
+            }
+            final long deadlineNanos = isFullAttempt
+                ? fullDeadlineNanos : incrementalDeadlineNanos;
+            JSONArray urls = attempt.optJSONArray("urls");
+            if (urls == null) {
+                continue;
+            }
+            for (int j = 0; j < urls.length(); j++) {
+                String url = urls.optString(j, "");
+                if (url.isEmpty()) {
+                    continue;
+                }
+                // Check before enqueueing: once the phase budget is gone we
+                // must not launch an orphan download that outlives the round.
+                long remainingNanos = deadlineNanos - System.nanoTime();
+                if (remainingNanos <= 0) {
+                    if (isFullAttempt) {
+                        return false;
+                    }
+                    break;
+                }
+                final CountDownLatch latch = new CountDownLatch(1);
+                final AtomicBoolean succeeded = new AtomicBoolean(false);
+                final String attemptType = type;
+                UpdateContext.DownloadFileListener listener =
+                    new UpdateContext.DownloadFileListener() {
+                        @Override
+                        public void onDownloadCompleted(DownloadTaskParams params) {
+                            succeeded.set(true);
+                            latch.countDown();
+                        }
+
+                        @Override
+                        public void onDownloadFailed(Throwable error) {
+                            Log.i(UpdateContext.TAG, "native check: " + attemptType
+                                + " attempt failed: " + error);
+                            latch.countDown();
+                        }
+                    };
+                if ("diff".equals(type)) {
+                    context.downloadPatchFromPpk(
+                        url, hash, originHash, listener, deadlineNanos);
+                } else if ("pdiff".equals(type)) {
+                    context.downloadPatchFromApk(
+                        url, hash, listener, deadlineNanos);
+                } else {
+                    context.downloadFullUpdate(
+                        url, hash, listener, deadlineNanos);
+                }
+                try {
+                    if (!latch.await(remainingNanos, TimeUnit.NANOSECONDS)) {
+                        Log.w(UpdateContext.TAG,
+                            "native check: download phase timed out during " + type);
+                        if (isFullAttempt) {
+                            return false;
+                        }
+                        break;
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    return false;
+                }
+                if (succeeded.get()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/NativeUpdateFlow.java

@@ -0,0 +1,23 @@
+package cn.reactnative.modules.update;
+
+/**
+ * JNI bindings to the shared update-flow decision layer
+ * (cpp/update_flow_core). String-in/string-out JSON on purpose — it matches
+ * the decision layer's own boundary and keeps this surface trivially stable.
+ * A null return means the input did not parse; callers skip the check round.
+ */
+final class NativeUpdateFlow {
+    static {
+        NativeUpdateCore.ensureLoaded();
+    }
+
+    private NativeUpdateFlow() {
+    }
+
+    static native String buildCheckRequestBody(String inputJson);
+
+    static native String orderEndpointCandidates(String endpointsJson, double randomSample);
+
+    static native String handleCheckResponse(
+        String responseText, String identityJson, String afterDownload);
+}

package/android/src/main/java/cn/reactnative/modules/update/PatchFailedException.java

@@ -0,0 +1,16 @@
+package cn.reactnative.modules.update;
+
+import java.io.IOException;
+
+/**
+ * A download task failure that happened after the artifact was fully
+ * downloaded — unzip, hdiff apply, or bundled-resource copy (including the
+ * copiesCrc content verification). UpdateModuleImpl rejects these with
+ * PATCH_FAILED instead of DOWNLOAD_FAILED so the JS layer and server-side
+ * telemetry can separate patch health from network health.
+ */
+class PatchFailedException extends IOException {
+    PatchFailedException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}