react-native-stallion 1.1.2 → 2.0.0-alpha.2

package/android/src/main/java/com/stallion/{StallionDefaultErrorActivity.java → utils/StallionErrorActivity.java}

@@ -1,27 +1,28 @@
-package com.stallion;
+package com.stallion.utils;
 
 import android.app.Activity;
 import android.os.Bundle;
-import android.util.Log;
 import android.widget.Button;
 import android.widget.TextView;
 
-public class StallionDefaultErrorActivity extends Activity {
-  private TextView stackTraceView;
-  private Button continueButton;
+import com.stallion.R;
+
+import java.util.Objects;
+
+public class StallionErrorActivity extends Activity {
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
-    Log.d("StallionDefault", "StallionDefaultErrorActivity");
-    String receivedStackTrace = getIntent().getExtras().getString("stack_trace_string");
+    String receivedStackTrace = Objects.requireNonNull(getIntent().getExtras()).getString("stack_trace_string");
     String stackTraceString = receivedStackTrace != null ? receivedStackTrace : "null";
     setContentView(R.layout.stallion_default_error_activity);
-    stackTraceView = findViewById(R.id.seb_stack_trace_text_view);
+    TextView stackTraceView = findViewById(R.id.seb_stack_trace_text_view);
     stackTraceView.setText(stackTraceString);
-    continueButton = findViewById(R.id.seb_continue_button);
+    Button continueButton = findViewById(R.id.seb_continue_button);
     continueButton.setOnClickListener(view -> continueExceptionFlow());
   }
   private void continueExceptionFlow() {
-    StallionErrorBoundary.continueExceptionFlow();
+    StallionExceptionHandler.continueExceptionFlow();
   }
 }
+

package/android/src/main/java/com/stallion/utils/StallionExceptionHandler.java

@@ -0,0 +1,102 @@
+package com.stallion.utils;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.stallion.events.StallionEventConstants;
+import com.stallion.events.StallionEventManager;
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.storage.StallionStateManager;
+
+import org.json.JSONObject;
+
+public class StallionExceptionHandler {
+
+  private static Thread.UncaughtExceptionHandler _androidUncaughtExceptionHandler;
+  private static Thread _exceptionThread;
+  private static Throwable _exceptionThrowable;
+  private static Activity _reactActivity;
+
+  public static void initErrorBoundary(ReactApplicationContext currentContext) {
+    _androidUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
+    _reactActivity = currentContext.getCurrentActivity();
+    Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
+      _exceptionThread = thread;
+      _exceptionThrowable = throwable;
+
+      // Safely trim the stack trace string
+      String stackTraceString = Log.getStackTraceString(throwable);
+      stackTraceString = stackTraceString.length() > 900
+        ? stackTraceString.substring(0, 900) + "..."
+        : stackTraceString;
+
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      StallionMetaConstants.SwitchState switchState = stateManager.stallionMeta.getSwitchState();
+
+      if (switchState == StallionMetaConstants.SwitchState.PROD) {
+        handleProdState(stackTraceString, stateManager);
+      } else if (switchState == StallionMetaConstants.SwitchState.STAGE) {
+        handleStageState(stackTraceString, stateManager);
+      } else {
+        continueExceptionFlow();
+      }
+    });
+  }
+
+  private static void emitException(String stackTraceString, String releaseHash, boolean isAutoRollback, boolean isProd) {
+    JSONObject syncErrorPayload = new JSONObject();
+    try {
+      syncErrorPayload.put("meta", stackTraceString);
+      syncErrorPayload.put("releaseHash", releaseHash);
+      syncErrorPayload.put("isAutoRollback", Boolean.toString(isAutoRollback));
+    } catch (Exception ignored) { }
+    StallionEventManager.getInstance().sendEvent(
+      isProd ?
+        StallionEventConstants.NativeProdEventTypes.EXCEPTION_PROD.toString()
+        : StallionEventConstants.NativeStageEventTypes.EXCEPTION_STAGE.toString(),
+      syncErrorPayload
+    );
+  }
+
+  private static void handleProdState(String stackTraceString, StallionStateManager stateManager) {
+    boolean isAutoRollback = !stateManager.getIsMounted();
+    String currentHash = stateManager.stallionMeta.getHashAtCurrentProdSlot();
+
+    // Emit exception event
+    emitException(stackTraceString, currentHash, isAutoRollback, true);
+
+    // Perform rollback if auto-rollback is enabled
+    if (isAutoRollback) {
+      StallionSlotManager.rollbackProd(true, stackTraceString);
+    }
+
+    continueExceptionFlow();
+  }
+
+  private static void handleStageState(String stackTraceString, StallionStateManager stateManager) {
+    boolean isAutoRollback = !stateManager.getIsMounted();
+    String currentStageHash = stateManager.stallionMeta.getStageNewHash();
+
+    // Emit exception event
+    emitException(stackTraceString, currentStageHash, isAutoRollback, false);
+
+    StallionSlotManager.rollbackStage();
+
+    if (_reactActivity != null) {
+      Intent errorIntent = new Intent(_reactActivity, StallionErrorActivity.class);
+      errorIntent.putExtra("stack_trace_string", stackTraceString);
+      _reactActivity.startActivity(errorIntent);
+      _reactActivity.finish();
+    } else {
+      continueExceptionFlow();
+    }
+  }
+
+  public static void continueExceptionFlow() {
+    if (_androidUncaughtExceptionHandler != null) {
+      _androidUncaughtExceptionHandler.uncaughtException(_exceptionThread, _exceptionThrowable);
+    }
+  }
+}

package/android/src/main/java/com/stallion/utils/StallionFileManager.java

@@ -0,0 +1,205 @@
+package com.stallion.utils;
+
+import android.os.Build;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class StallionFileManager {
+
+  // Constants
+  private static final int BUFFER_SIZE = 4096;
+  private static final String CHARSET_UTF_8 = "UTF-8";
+  private static final String FILE_NOT_FOUND_ERROR = "File does not exist: ";
+  private static final String SECURITY_EXCEPTION_MESSAGE = "Zip Path Traversal Vulnerability: ";
+
+  /**
+   * Unzips a given ZIP file to the specified destination directory.
+   *
+   * @param zipFilePath    The path to the ZIP file.
+   * @param destDirectory  The destination directory where the contents will be extracted.
+   */
+  public static void unzipFile(String zipFilePath, String destDirectory) {
+    validateFileExists(zipFilePath);
+    try (ZipFile zipFile = openZipFile(zipFilePath)) {
+      extractZipEntries(zipFile, destDirectory);
+    } catch (IOException e) {
+      throw new RuntimeException("Error unzipping file: " + e.getMessage(), e);
+    }
+  }
+
+  private static void validateFileExists(String filePath) {
+    File file = new File(filePath);
+    if (!file.exists()) {
+      throw new IllegalArgumentException(FILE_NOT_FOUND_ERROR + filePath);
+    }
+  }
+
+  private static ZipFile openZipFile(String zipFilePath) throws IOException {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      return new ZipFile(zipFilePath, Charset.forName(CHARSET_UTF_8));
+    } else {
+      return new ZipFile(zipFilePath);
+    }
+  }
+
+  private static void extractZipEntries(ZipFile zipFile, String destDirectory) throws IOException {
+    Enumeration<? extends ZipEntry> entries = zipFile.entries();
+    while (entries.hasMoreElements()) {
+      extractZipEntry(entries.nextElement(), destDirectory, zipFile);
+    }
+  }
+
+  private static void extractZipEntry(ZipEntry entry, String destDirectory, ZipFile zipFile) throws IOException {
+    if (entry.isDirectory()) return;
+
+    File outputFile = new File(destDirectory, entry.getName());
+    validateZipEntryPath(outputFile, destDirectory);
+    createParentDirectory(outputFile);
+
+    try (InputStream in = zipFile.getInputStream(entry);
+         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outputFile))) {
+      copy(in, out);
+    }
+  }
+
+  private static void validateZipEntryPath(File outputFile, String destDirectory) throws IOException {
+    String canonicalPath = outputFile.getCanonicalPath();
+    String canonicalDestDir = new File(destDirectory).getCanonicalPath() + File.separator;
+    if (!canonicalPath.startsWith(canonicalDestDir)) {
+      throw new SecurityException(SECURITY_EXCEPTION_MESSAGE + canonicalPath);
+    }
+  }
+
+  private static void createParentDirectory(File file) {
+    File parentDir = file.getParentFile();
+    if (parentDir != null && !parentDir.exists() && !parentDir.mkdirs()) {
+      throw new RuntimeException("Failed to create parent directory: " + parentDir);
+    }
+  }
+
+  private static long copy(InputStream from, OutputStream to) throws IOException {
+    byte[] buffer = new byte[BUFFER_SIZE];
+    long total = 0;
+    int bytesRead;
+    while ((bytesRead = from.read(buffer)) != -1) {
+      to.write(buffer, 0, bytesRead);
+      total += bytesRead;
+    }
+    return total;
+  }
+
+  /**
+   * Deletes a file or directory silently. If it's a directory, all its contents are deleted recursively.
+   *
+   * @param file The file or directory to delete.
+   */
+  public static void deleteFileOrFolderSilently(File file) {
+    if(file.exists()) {
+      if (file.isDirectory()) {
+        File[] files = file.listFiles();
+        if (files != null) {
+          for (File child : files) {
+            deleteFileOrFolderSilently(child);
+          }
+        }
+      }
+      if (!file.delete()) {
+        throw new RuntimeException("Failed to delete file: " + file.getAbsolutePath());
+      }
+    }
+  }
+
+  /**
+   * Moves a file from one location to another. If the destination file exists, it is replaced.
+   *
+   * @param fromFile Source file.
+   * @param toFile   Destination file.
+   */
+  public static void moveFile(File fromFile, File toFile) {
+    if (toFile.exists()) {
+      deleteFileOrFolderSilently(toFile);
+    }
+    if (!toFile.getParentFile().exists() && !toFile.getParentFile().mkdirs()) {
+      throw new RuntimeException("Failed to create destination directory: " + toFile.getParent());
+    }
+    if (!fromFile.renameTo(toFile)) {
+      copyFileOrDirectory(fromFile, toFile);
+      deleteFileOrFolderSilently(fromFile);
+    }
+  }
+
+  /**
+   * Copies a file or directory to the specified destination.
+   *
+   * @param source      The source file or directory.
+   * @param destination The destination file or directory.
+   */
+  public static void copyFileOrDirectory(File source, File destination) {
+    if (!source.exists()) {
+      throw new IllegalArgumentException("Source does not exist: " + source.getAbsolutePath());
+    }
+
+    if (source.isDirectory()) {
+      // If the source is a directory, copy recursively
+      copyDirectory(source, destination);
+    } else {
+      // If the source is a file, copy the file
+      copyFile(source, destination);
+    }
+  }
+
+  /**
+   * Recursively copies a directory and its contents to a destination.
+   *
+   * @param sourceDir      The source directory to copy.
+   * @param destinationDir The destination directory.
+   */
+  public static void copyDirectory(File sourceDir, File destinationDir) {
+    if (!sourceDir.exists()) {
+      throw new IllegalArgumentException("Source directory does not exist: " + sourceDir.getAbsolutePath());
+    }
+    if (!sourceDir.isDirectory()) {
+      throw new IllegalArgumentException("Source is not a directory: " + sourceDir.getAbsolutePath());
+    }
+
+    // Ensure destination directory exists
+    if (!destinationDir.exists() && !destinationDir.mkdirs()) {
+      throw new RuntimeException("Failed to create destination directory: " + destinationDir.getAbsolutePath());
+    }
+
+    File[] files = sourceDir.listFiles();
+    if (files == null) {
+      throw new RuntimeException("Failed to list files in directory: " + sourceDir.getAbsolutePath());
+    }
+
+    for (File file : files) {
+      File destFile = new File(destinationDir, file.getName());
+      if (file.isDirectory()) {
+        // Recursively copy subdirectories
+        copyDirectory(file, destFile);
+      } else {
+        // Copy individual files
+        copyFile(file, destFile);
+      }
+    }
+  }
+
+  public static void copyFile(File source, File destination) {
+    try (InputStream in = new FileInputStream(source);
+         OutputStream out = new FileOutputStream(destination)) {
+      copy(in, out);
+    } catch (IOException e) {
+      throw new RuntimeException("Failed to copy file: " + e.getMessage(), e);
+    }
+  }
+}

package/android/src/main/java/com/stallion/utils/StallionSlotManager.java

@@ -0,0 +1,110 @@
+package com.stallion.utils;
+
+import com.stallion.events.StallionEventManager;
+import com.stallion.storage.StallionConfigConstants;
+import com.stallion.storage.StallionMetaConstants;
+import com.stallion.storage.StallionStateManager;
+import com.stallion.events.StallionEventConstants.NativeProdEventTypes;
+
+import org.json.JSONObject;
+
+import java.io.File;
+
+public class StallionSlotManager {
+
+  private static final StallionStateManager stateManager = StallionStateManager.getInstance();
+  private static final String baseFolderPath = stateManager.getStallionConfig().getFilesDirectory();
+
+  public static void rollbackProd(boolean isAutoRollback, String errorString) {
+    StallionMetaConstants.SlotStates currentProdSlot = stateManager.stallionMeta.getCurrentProdSlot();
+    String stableReleaseHash = stateManager.stallionMeta.getProdStableHash();
+    String newReleaseHash = stateManager.stallionMeta.getProdNewHash();
+
+    switch (currentProdSlot) {
+      case NEW_SLOT:
+        stateManager.stallionMeta.setProdNewHash("");
+        if (stableReleaseHash.isEmpty()) {
+          stateManager.stallionMeta.setCurrentProdSlot(StallionMetaConstants.SlotStates.DEFAULT_SLOT);
+        } else {
+          stateManager.stallionMeta.setCurrentProdSlot(StallionMetaConstants.SlotStates.STABLE_SLOT);
+        }
+        emitRollbackEvent(isAutoRollback, newReleaseHash, errorString);
+        stateManager.syncStallionMeta();
+        break;
+
+      case STABLE_SLOT:
+        stateManager.stallionMeta.setProdStableHash("");
+        stateManager.stallionMeta.setCurrentProdSlot(StallionMetaConstants.SlotStates.DEFAULT_SLOT);
+        emitRollbackEvent(isAutoRollback, stableReleaseHash, errorString);
+        stateManager.syncStallionMeta();
+        break;
+
+      default:
+        // Default slot, no rollback needed
+        break;
+    }
+  }
+
+  public static void fallbackProd() {
+    StallionFileManager.deleteFileOrFolderSilently(new File(baseFolderPath + StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT));
+    StallionFileManager.deleteFileOrFolderSilently(new File(baseFolderPath + StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.STABLE_FOLDER_SLOT));
+    StallionFileManager.deleteFileOrFolderSilently(new File(baseFolderPath + StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.TEMP_FOLDER_SLOT));
+    stateManager.clearStallionMeta();
+  }
+
+  public static void rollbackStage() {
+    stateManager.stallionMeta.setCurrentStageSlot(StallionMetaConstants.SlotStates.DEFAULT_SLOT);
+    stateManager.stallionMeta.setStageNewHash("");
+    stateManager.syncStallionMeta();
+  }
+
+  public static void stabilizeProd() {
+    try {
+      File newSlot = new File(baseFolderPath, StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.NEW_FOLDER_SLOT);
+      File stableSlot = new File(baseFolderPath, StallionConfigConstants.PROD_DIRECTORY + StallionConfigConstants.STABLE_FOLDER_SLOT);
+
+      StallionFileManager.copyDirectory(newSlot, stableSlot);
+
+      String newReleaseHash = stateManager.stallionMeta.getProdNewHash();
+      stateManager.stallionMeta.setProdStableHash(newReleaseHash);
+      stateManager.syncStallionMeta();
+      emitStabilizeEvent(newReleaseHash);
+    } catch (Exception ignored) {}
+  }
+
+  private static void emitRollbackEvent(boolean isAutoRollback, String rolledBackReleaseHash, String errorString) {
+    try {
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", rolledBackReleaseHash);
+      eventPayload.put("meta", errorString);
+
+      String eventName = isAutoRollback
+        ? NativeProdEventTypes.AUTO_ROLLED_BACK_PROD.toString()
+        : NativeProdEventTypes.ROLLED_BACK_PROD.toString();
+
+      if (isAutoRollback) {
+        stateManager.stallionMeta.setLastRolledBackHash(rolledBackReleaseHash);
+        stateManager.syncStallionMeta();
+      }
+
+      StallionEventManager.getInstance().sendEvent(eventName, eventPayload);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  private static void emitStabilizeEvent(String newReleaseHash) {
+    try {
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", newReleaseHash);
+
+      StallionEventManager.getInstance().sendEvent(
+        NativeProdEventTypes.STABILIZED_PROD.toString(),
+        eventPayload
+      );
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}
+

package/ios/main/Stallion-Bridging-Header.h

@@ -1,4 +1,9 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
 #import <React/RCTEventEmitter.h>
-#import <StallionErrorBoundary.h>
+#import <StallionObjConstants.h>
+#import <StallionStateManager.h>
+#import <StallionEventHandler.h>
+#import <StallionMetaConstants.h>
+#import <StallionSlotManager.h>
+#import <StallionExceptionHandler.h>

package/ios/main/Stallion.m

@@ -3,15 +3,34 @@
 
 @interface RCT_EXTERN_MODULE(Stallion, NSObject)
 
-RCT_EXTERN_METHOD(downloadPackage:(NSDictionary *)bundleInfo
-                  withResolver:(RCTPromiseResolveBlock)resolve
-                  withRejecter:(RCTPromiseRejectBlock)reject
-                  )
-
-RCT_EXTERN_METHOD(getStallionMeta: (RCTResponseSenderBlock)callback)
-RCT_EXTERN_METHOD(getApiKey: (RCTResponseSenderBlock)callback)
-RCT_EXTERN_METHOD(setApiKey: (NSString *)apiKey)
-RCT_EXTERN_METHOD(toggleStallionSwitch: (BOOL *)isOn)
+RCT_EXTERN_METHOD(onLaunch: (NSString *)launchMessage)
+
+RCT_EXTERN_METHOD(sync)
+
+RCT_EXTERN_METHOD(downloadStageBundle: (NSDictionary *)bundleInfo
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(getStallionConfig: (RCTPromiseResolveBlock)promise
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(getStallionMeta: (RCTPromiseResolveBlock)promise
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(toggleStallionSwitch: (NSString *)switchState
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(updateSdkToken: (NSString *)newSdkToken
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(popEvents: (RCTPromiseResolveBlock)promise
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(acknowledgeEvents: (NSString *)eventIdsJson
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
 
 + (BOOL)requiresMainQueueSetup
 {