react-native-update 10.37.20 → 10.38.0-beta.0

package/scripts/test-patch-core.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+set -eu
+
+ROOT_DIR="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)"
+BUILD_DIR="$ROOT_DIR/.tmp/patch-core-tests"
+
+mkdir -p "$BUILD_DIR"
+
+COMMON_INCLUDES="
+  -I$ROOT_DIR/cpp/patch_core
+  -I$ROOT_DIR/android/jni
+  -I$ROOT_DIR/android/jni/HDiffPatch
+  -I$ROOT_DIR/android/jni/HDiffPatch/libHDiffPatch/HPatch
+  -I$ROOT_DIR/android/jni/lzma/C
+"
+
+cc -Wall -Wextra $COMMON_INCLUDES -c "$ROOT_DIR/android/jni/hpatch.c" -o "$BUILD_DIR/hpatch.o"
+cc -Wall -Wextra $COMMON_INCLUDES -c "$ROOT_DIR/android/jni/HDiffPatch/libHDiffPatch/HPatch/patch.c" -o "$BUILD_DIR/patch.o"
+cc -Wall -Wextra $COMMON_INCLUDES -c "$ROOT_DIR/android/jni/HDiffPatch/file_for_patch.c" -o "$BUILD_DIR/file_for_patch.o"
+cc -Wall -Wextra $COMMON_INCLUDES -c "$ROOT_DIR/android/jni/lzma/C/LzmaDec.c" -o "$BUILD_DIR/LzmaDec.o"
+cc -Wall -Wextra $COMMON_INCLUDES -c "$ROOT_DIR/android/jni/lzma/C/Lzma2Dec.c" -o "$BUILD_DIR/Lzma2Dec.o"
+
+c++ \
+  -std=c++17 \
+  -Wall \
+  -Wextra \
+  $COMMON_INCLUDES \
+  "$ROOT_DIR/cpp/patch_core/tests/patch_core_test.cpp" \
+  "$ROOT_DIR/cpp/patch_core/archive_patch_core.cpp" \
+  "$ROOT_DIR/cpp/patch_core/patch_core.cpp" \
+  "$ROOT_DIR/cpp/patch_core/state_core.cpp" \
+  "$BUILD_DIR/hpatch.o" \
+  "$BUILD_DIR/patch.o" \
+  "$BUILD_DIR/file_for_patch.o" \
+  "$BUILD_DIR/LzmaDec.o" \
+  "$BUILD_DIR/Lzma2Dec.o" \
+  -o "$BUILD_DIR/patch_core_test"
+
+"$BUILD_DIR/patch_core_test"

package/src/client.ts

@@ -17,11 +17,18 @@ import {
   setLocalHashInfo,
 } from './core';
 import { PermissionsAndroid } from './permissions';
-import { CheckResult, ClientOptions, EventType, ProgressData } from './type';
+import {
+  CheckResult,
+  ClientOptions,
+  EventType,
+  ProgressData,
+  UpdateServerConfig,
+} from './type';
 import {
   assertWeb,
+  DEFAULT_FETCH_TIMEOUT_MS,
   emptyObj,
-  enhancedFetch,
+  fetchWithTimeout,
   info,
   joinUrls,
   log,
@@ -30,6 +37,7 @@ import {
   testUrls,
 } from './utils';
 import i18n from './i18n';
+import { dedupeEndpoints, executeEndpointFallback } from './endpoint';
 
 const SERVER_PRESETS = {
   // cn
@@ -63,6 +71,19 @@ const defaultClientOptions: ClientOptions = {
   throwError: false,
 };
 
+const cloneServerConfig = (
+  server?: UpdateServerConfig,
+): UpdateServerConfig | undefined => {
+  if (!server) {
+    return undefined;
+  }
+  return {
+    main: server.main,
+    backups: server.backups ? [...server.backups] : undefined,
+    queryUrls: server.queryUrls ? [...server.queryUrls] : undefined,
+  };
+};
+
 export const sharedState: {
   progressHandlers: Record<string, EmitterSubscription>;
   downloadedHash?: string;
@@ -110,7 +131,7 @@ export class Pushy {
 
   constructor(options: ClientOptions, clientType?: 'Pushy' | 'Cresc') {
     this.clientType = clientType || 'Pushy';
-    this.options.server = SERVER_PRESETS[this.clientType];
+    this.options.server = cloneServerConfig(SERVER_PRESETS[this.clientType]);
 
     i18n.setLocale(options.locale ?? this.clientType === 'Pushy' ? 'zh' : 'en');
 
@@ -134,7 +155,10 @@ export class Pushy {
   setOptions = (options: Partial<ClientOptions>) => {
     for (const [key, value] of Object.entries(options)) {
       if (value !== undefined) {
-        (this.options as any)[key] = value;
+        (this.options as any)[key] =
+          key === 'server'
+            ? cloneServerConfig(value as UpdateServerConfig)
+            : value;
         if (key === 'logger') {
           this.loggerPromise.resolve();
         }
@@ -188,6 +212,90 @@ export class Pushy {
   getCheckUrl = (endpoint: string = this.options.server!.main) => {
     return `${endpoint}/checkUpdate/${this.options.appKey}`;
   };
+  getConfiguredCheckEndpoints = () => {
+    const { server } = this.options;
+    if (!server) {
+      return [];
+    }
+    return dedupeEndpoints([server.main, ...(server.backups || [])]);
+  };
+  getRemoteEndpoints = async () => {
+    const { server } = this.options;
+    if (!server?.queryUrls?.length) {
+      return [];
+    }
+    try {
+      const resp = await promiseAny(
+        server.queryUrls.map(queryUrl =>
+          fetchWithTimeout(queryUrl, {}, DEFAULT_FETCH_TIMEOUT_MS),
+        ),
+      );
+      const remoteEndpoints = await resp.json();
+      log('fetch endpoints:', remoteEndpoints);
+      if (Array.isArray(remoteEndpoints)) {
+        const normalizedRemoteEndpoints = dedupeEndpoints(
+          remoteEndpoints.filter(
+            (endpoint): endpoint is string => typeof endpoint === 'string',
+          ),
+        ).filter(endpoint => endpoint !== server.main);
+        server.backups = dedupeEndpoints([
+          ...(server.backups || []),
+          ...normalizedRemoteEndpoints,
+        ]).filter(endpoint => endpoint !== server.main);
+        return normalizedRemoteEndpoints;
+      }
+    } catch (e) {
+      log('failed to fetch endpoints from: ', server.queryUrls, e);
+    }
+    return [];
+  };
+  requestCheckResult = async (
+    endpoint: string,
+    fetchPayload: Parameters<typeof fetch>[1],
+  ) => {
+    const resp = await fetchWithTimeout(
+      this.getCheckUrl(endpoint),
+      fetchPayload,
+      DEFAULT_FETCH_TIMEOUT_MS,
+    );
+
+    if (!resp.ok) {
+      const respText = await resp.text();
+      throw Error(
+        this.t('error_http_status', {
+          status: resp.status,
+          statusText: respText,
+        }),
+      );
+    }
+
+    return (await resp.json()) as CheckResult;
+  };
+  fetchCheckResult = async (fetchPayload: Parameters<typeof fetch>[1]) => {
+    const { endpoint, value } = await executeEndpointFallback<CheckResult>({
+      configuredEndpoints: this.getConfiguredCheckEndpoints(),
+      getRemoteEndpoints: this.getRemoteEndpoints,
+      tryEndpoint: async currentEndpoint => {
+        try {
+          return await this.requestCheckResult(currentEndpoint, fetchPayload);
+        } catch (e) {
+          log('check endpoint failed', currentEndpoint, e);
+          throw e;
+        }
+      },
+      onFirstFailure: ({ error }) => {
+        this.report({
+          type: 'errorChecking',
+          message: this.t('error_cannot_connect_backup', {
+            message: error.message,
+          }),
+        });
+      },
+    });
+
+    log('check endpoint success', endpoint);
+    return value;
+  };
   assertDebug = (matter: string) => {
     if (__DEV__ && !this.options.debug) {
       info(this.t('dev_debug_disabled', { matter }));
@@ -271,95 +379,40 @@ export class Pushy {
       },
       body,
     };
-    let resp;
+    const previousRespJson = this.lastRespJson;
     try {
       this.report({
         type: 'checking',
         message: this.options.appKey + ': ' + stringifyBody,
       });
-      resp = await enhancedFetch(this.getCheckUrl(), fetchPayload);
-    } catch (e: any) {
-      this.report({
-        type: 'errorChecking',
-        message: this.t('error_cannot_connect_backup', { message: e.message }),
-      });
-      const backupEndpoints = await this.getBackupEndpoints().catch();
-      if (backupEndpoints) {
-        resp = await promiseAny(
-          backupEndpoints.map(endpoint =>
-            enhancedFetch(this.getCheckUrl(endpoint), fetchPayload),
-          ),
-        ).catch(() => {
-          this.report({
-            type: 'errorChecking',
-            message: this.t('errorCheckingUseBackup'),
-          });
-        });
-      } else {
-        this.report({
-          type: 'errorChecking',
-          message: this.t('errorCheckingGetBackup'),
-        });
-      }
-    }
-    if (!resp) {
-      this.report({
-        type: 'errorChecking',
-        message: this.t('error_cannot_connect_server'),
-      });
-      this.throwIfEnabled(Error('errorChecking'));
-      return this.lastRespJson ? await this.lastRespJson : emptyObj;
-    }
+      const respJsonPromise = this.fetchCheckResult(fetchPayload);
+      this.lastRespJson = respJsonPromise;
+      const result: CheckResult = await respJsonPromise;
 
-    if (!resp.ok) {
-      const respText = await resp.text();
-      const errorMessage = this.t('error_http_status', {
-        status: resp.status,
-        statusText: respText,
-      });
+      log('checking result:', result);
+
+      return result;
+    } catch (e: any) {
+      this.lastRespJson = previousRespJson;
+      const errorMessage =
+        e?.message || this.t('error_cannot_connect_server');
       this.report({
         type: 'errorChecking',
         message: errorMessage,
       });
-      this.throwIfEnabled(Error('errorChecking: ' + errorMessage));
-      return this.lastRespJson ? await this.lastRespJson : emptyObj;
+      this.throwIfEnabled(e);
+      return previousRespJson ? await previousRespJson : emptyObj;
     }
-    const respJsonPromise = resp.json() as Promise<CheckResult>;
-    this.lastRespJson = respJsonPromise;
-
-    const result: CheckResult = await respJsonPromise;
-
-    log('checking result:', result);
-
-    return result;
   };
   getBackupEndpoints = async () => {
     const { server } = this.options;
     if (!server) {
       return [];
     }
-    if (server.queryUrls) {
-      try {
-        const resp = await promiseAny(
-          server.queryUrls.map(queryUrl => fetch(queryUrl)),
-        );
-        const remoteEndpoints = await resp.json();
-        log('fetch endpoints:', remoteEndpoints);
-        if (Array.isArray(remoteEndpoints)) {
-          const backups = server.backups || [];
-          const set = new Set(backups);
-          for (const endpoint of remoteEndpoints) {
-            set.add(endpoint);
-          }
-          if (set.size !== backups.length) {
-            server.backups = Array.from(set);
-          }
-        }
-      } catch (e: any) {
-        log('failed to fetch endpoints from: ', server.queryUrls);
-      }
-    }
-    return server.backups;
+    const remoteEndpoints = await this.getRemoteEndpoints();
+    return dedupeEndpoints([...(server.backups || []), ...remoteEndpoints]).filter(
+      endpoint => endpoint !== server.main,
+    );
   };
   downloadUpdate = async (
     updateInfo: CheckResult,

package/src/core.ts

@@ -1,6 +1,7 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import { emptyModule, error, log } from './utils';
 import i18n from './i18n';
+/* eslint-disable @react-native/no-deep-imports */
 const {
   version: v,
 } = require('react-native/Libraries/Core/ReactNativeVersion');
@@ -47,7 +48,7 @@ if (currentVersionInfoString) {
       delete _currentVersionInfo.debugChannel;
       setLocalHashInfo(currentVersion, _currentVersionInfo);
     }
-  } catch (err) {
+  } catch {
     error(
       i18n.t('error_parse_version_info', { info: currentVersionInfoString }),
     );

package/src/endpoint.ts

@@ -0,0 +1,171 @@
+export interface EndpointAttemptSuccess<T> {
+  endpoint: string;
+  value: T;
+  duration: number;
+}
+
+export interface EndpointAttemptFailure {
+  endpoint: string;
+  error: Error;
+}
+
+export interface ExecuteEndpointFallbackOptions<T> {
+  configuredEndpoints: string[];
+  getRemoteEndpoints?: () => Promise<string[]>;
+  tryEndpoint: (endpoint: string) => Promise<T>;
+  random?: () => number;
+  now?: () => number;
+  onFirstFailure?: (failure: EndpointAttemptFailure) => void | Promise<void>;
+}
+
+const normalizeError = (error: unknown) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+};
+
+export const dedupeEndpoints = (
+  endpoints: Array<string | null | undefined>,
+): string[] => {
+  const result: string[] = [];
+  const visited = new Set<string>();
+
+  for (const endpoint of endpoints) {
+    if (!endpoint || visited.has(endpoint)) {
+      continue;
+    }
+    visited.add(endpoint);
+    result.push(endpoint);
+  }
+
+  return result;
+};
+
+export const pickRandomEndpoint = (
+  endpoints: string[],
+  random: () => number = Math.random,
+) => {
+  if (!endpoints.length) {
+    throw new Error('No endpoints configured');
+  }
+  return endpoints[Math.floor(random() * endpoints.length)];
+};
+
+export async function selectFastestSuccessfulEndpoint<T>(
+  endpoints: string[],
+  tryEndpoint: (endpoint: string) => Promise<T>,
+  now: () => number = Date.now,
+): Promise<{
+  successes: EndpointAttemptSuccess<T>[];
+  failures: EndpointAttemptFailure[];
+}> {
+  const attempts = await Promise.all(
+    endpoints.map(async endpoint => {
+      const start = now();
+      try {
+        const value = await tryEndpoint(endpoint);
+        return {
+          ok: true as const,
+          endpoint,
+          value,
+          duration: now() - start,
+        };
+      } catch (error) {
+        return {
+          ok: false as const,
+          endpoint,
+          error: normalizeError(error),
+        };
+      }
+    }),
+  );
+
+  const successes: EndpointAttemptSuccess<T>[] = [];
+  const failures: EndpointAttemptFailure[] = [];
+
+  for (const attempt of attempts) {
+    if (attempt.ok) {
+      successes.push({
+        endpoint: attempt.endpoint,
+        value: attempt.value,
+        duration: attempt.duration,
+      });
+      continue;
+    }
+
+    failures.push({
+      endpoint: attempt.endpoint,
+      error: attempt.error,
+    });
+  }
+
+  successes.sort((left, right) => left.duration - right.duration);
+
+  return {
+    successes,
+    failures,
+  };
+}
+
+export async function executeEndpointFallback<T>({
+  configuredEndpoints,
+  getRemoteEndpoints,
+  tryEndpoint,
+  random = Math.random,
+  now = Date.now,
+  onFirstFailure,
+}: ExecuteEndpointFallbackOptions<T>): Promise<EndpointAttemptSuccess<T>> {
+  const excludedEndpoints = new Set<string>();
+  let candidates = dedupeEndpoints(configuredEndpoints);
+
+  if (!candidates.length) {
+    throw new Error('No endpoints configured');
+  }
+
+  const firstEndpoint = pickRandomEndpoint(candidates, random);
+
+  try {
+    return {
+      endpoint: firstEndpoint,
+      value: await tryEndpoint(firstEndpoint),
+      duration: 0,
+    };
+  } catch (error) {
+    const firstFailure = {
+      endpoint: firstEndpoint,
+      error: normalizeError(error),
+    };
+    excludedEndpoints.add(firstEndpoint);
+    await onFirstFailure?.(firstFailure);
+    let lastError = firstFailure.error;
+
+    while (true) {
+      const remoteEndpoints = getRemoteEndpoints
+        ? await getRemoteEndpoints().catch(() => [])
+        : [];
+      candidates = dedupeEndpoints([...candidates, ...remoteEndpoints]).filter(
+        endpoint => !excludedEndpoints.has(endpoint),
+      );
+
+      if (!candidates.length) {
+        throw lastError;
+      }
+
+      const { successes, failures } = await selectFastestSuccessfulEndpoint(
+        candidates,
+        tryEndpoint,
+        now,
+      );
+
+      if (successes.length) {
+        return successes[0];
+      }
+
+      for (const failure of failures) {
+        excludedEndpoints.add(failure.endpoint);
+        lastError = failure.error;
+      }
+    }
+  }
+}

package/src/utils.ts

@@ -18,6 +18,7 @@ export function error(...args: any[]) {
 }
 
 export const isWeb = Platform.OS === 'web';
+export const DEFAULT_FETCH_TIMEOUT_MS = 5000;
 
 export function promiseAny<T>(promises: Promise<T>[]) {
   return new Promise<T>((resolve, reject) => {
@@ -52,33 +53,23 @@ export const emptyModule = new EmptyModule();
 const ping = isWeb
   ? Promise.resolve
   : async (url: string) => {
-      let pingFinished = false;
-      return Promise.race([
-        enhancedFetch(url, {
-          method: 'HEAD',
-        })
-          .then(({ status, statusText, url: finalUrl }) => {
-            pingFinished = true;
-            if (status === 200) {
-              return finalUrl;
-            }
-            log('ping failed', url, status, statusText);
-            throw Error(i18n.t('error_ping_failed'));
-          })
-          .catch(e => {
-            pingFinished = true;
-            log('ping error', url, e);
-            throw e;
-          }),
-        new Promise((_, reject) =>
-          setTimeout(() => {
-            reject(Error(i18n.t('error_ping_timeout')));
-            if (!pingFinished) {
-              log('ping timeout', url);
-            }
-          }, 5000),
-        ),
-      ]);
+      try {
+        const { status, statusText, url: finalUrl } = await fetchWithTimeout(
+          url,
+          {
+            method: 'HEAD',
+          },
+          DEFAULT_FETCH_TIMEOUT_MS,
+        );
+        if (status === 200) {
+          return finalUrl;
+        }
+        log('ping failed', url, status, statusText);
+        throw Error(i18n.t('error_ping_failed'));
+      } catch (e) {
+        log('ping error', url, e);
+        throw e;
+      }
     };
 
 export function joinUrls(paths: string[], fileName?: string) {
@@ -111,6 +102,28 @@ export const assertWeb = () => {
   return true;
 };
 
+export const fetchWithTimeout = (
+  url: string,
+  params: Parameters<typeof fetch>[1],
+  timeoutMs = DEFAULT_FETCH_TIMEOUT_MS,
+): Promise<Response> => {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  return Promise.race([
+    enhancedFetch(url, params),
+    new Promise<Response>((_, reject) => {
+      timeoutId = setTimeout(() => {
+        log('fetch timeout', url);
+        reject(Error(i18n.t('error_ping_timeout')));
+      }, timeoutMs);
+    }),
+  ]).finally(() => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  });
+};
+
 // export const isAndroid70AndBelow = () => {
 //   // android 7.0 and below devices do not support letsencrypt cert
 //   // https://letsencrypt.org/2023/07/10/cross-sign-expiration/