WIP proxy handling

gthea · gthea · commit 5624dd6c0ef8 · 2025-04-29T13:11:25.000-03:00
diff --git a/src/main/java/io/split/android/client/service/executor/SplitTaskFactoryImpl.java b/src/main/java/io/split/android/client/service/executor/SplitTaskFactoryImpl.java
@@ -110,7 +110,8 @@ public SplitTaskFactoryImpl(@NonNull SplitClientConfig splitClientConfig,
                     mRuleBasedSegmentChangeProcessor,
                     ruleBasedSegmentStorageProducer,
                     mTelemetryRuntimeProducer,
-                    flagsSpecFromConfig);
+                    flagsSpecFromConfig,
+                    false);
         }
 
         mFilters = (filters == null) ? new ArrayList<>() : new ArrayList<>(filters.values());
diff --git a/src/main/java/io/split/android/client/service/http/HttpStatus.java b/src/main/java/io/split/android/client/service/http/HttpStatus.java
@@ -52,7 +52,7 @@ public static boolean isNotRetryable(Integer code) {
         return isNotRetryable(fromCode(code));
     }
 
-    public static boolean isProxyOutdated(Integer code) {
-        return fromCode(code) == HttpStatus.INTERNAL_PROXY_OUTDATED;
+    public static boolean isProxyOutdated(HttpStatus status) {
+        return status == HttpStatus.INTERNAL_PROXY_OUTDATED;
     }
 }
diff --git a/src/main/java/io/split/android/client/service/splits/OutdatedSplitProxyHandler.java b/src/main/java/io/split/android/client/service/splits/OutdatedSplitProxyHandler.java
@@ -0,0 +1,61 @@
+package io.split.android.client.service.splits;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+
+import io.split.android.client.utils.logger.Logger;
+
+public class OutdatedSplitProxyHandler {
+
+    private final String mLatestSpec;
+    private final String mPreviousSpec;
+    private static final long PROXY_CHECK_INTERNAL_MILLIS = TimeUnit.HOURS.toMillis(1);
+    private final AtomicReference<String> mCurrentSpec;
+    private final AtomicLong mLastProxyCheckTimestamp = new AtomicLong(0); // TODO, persist
+    private final boolean mForBackgroundSync;
+
+    OutdatedSplitProxyHandler(String flagSpec, String previousSpec, boolean forBackgroundSync) {
+        mLatestSpec = flagSpec;
+        mPreviousSpec = previousSpec;
+        mCurrentSpec = new AtomicReference<>(flagSpec);
+        mForBackgroundSync = forBackgroundSync;
+    }
+
+    ProxyHandlingType handle() {
+        if (mForBackgroundSync) {
+            Logger.i("Background sync fetch; skipping proxy handling");
+            return ProxyHandlingType.NONE;
+        }
+
+        if (mCurrentSpec.get().equals(mLatestSpec)) {
+            Logger.i("Switching to previous spec: " + mPreviousSpec);
+
+            mLastProxyCheckTimestamp.set(System.currentTimeMillis());
+
+            mCurrentSpec.set(mPreviousSpec);
+
+            return ProxyHandlingType.FALLBACK;
+        } else if (mCurrentSpec.get().equals(mPreviousSpec)) {
+            if (System.currentTimeMillis() - mLastProxyCheckTimestamp.get() > PROXY_CHECK_INTERNAL_MILLIS) {
+                Logger.i("Attempting recovery with latest spec: " + mLatestSpec);
+                return ProxyHandlingType.RECOVERY;
+            }
+        }
+
+        return ProxyHandlingType.NONE;
+    }
+
+    String getCurrentSpec() {
+        return mCurrentSpec.get();
+    }
+
+    enum ProxyHandlingType {
+        // no action
+        NONE,
+        // switch to previous spec
+        FALLBACK,
+        // attempt recovery
+        RECOVERY,
+    }
+}
diff --git a/src/main/java/io/split/android/client/service/splits/SplitsSyncHelper.java b/src/main/java/io/split/android/client/service/splits/SplitsSyncHelper.java
@@ -46,26 +46,27 @@ public class SplitsSyncHelper {
     private final RuleBasedSegmentStorageProducer mRuleBasedSegmentStorage;
     private final TelemetryRuntimeProducer mTelemetryRuntimeProducer;
     private final BackoffCounter mBackoffCounter;
-    private final String mFlagsSpec;
+    private final OutdatedSplitProxyHandler mOutdatedSplitProxyHandler;
 
     public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
                             @NonNull SplitsStorage splitsStorage,
                             @NonNull SplitChangeProcessor splitChangeProcessor,
                             @NonNull RuleBasedSegmentChangeProcessor ruleBasedSegmentChangeProcessor,
                             @NonNull RuleBasedSegmentStorageProducer ruleBasedSegmentStorage,
                             @NonNull TelemetryRuntimeProducer telemetryRuntimeProducer,
-                            @Nullable String flagsSpec) {
+                            @Nullable String flagsSpec,
+                            boolean forBackgroundSync) {
         this(splitFetcher,
                 splitsStorage,
                 splitChangeProcessor,
                 ruleBasedSegmentChangeProcessor,
                 ruleBasedSegmentStorage,
                 telemetryRuntimeProducer,
                 new ReconnectBackoffCounter(1, ON_DEMAND_FETCH_BACKOFF_MAX_WAIT),
-                flagsSpec);
+                flagsSpec,
+                forBackgroundSync);
     }
 
-    @VisibleForTesting
     public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
                             @NonNull SplitsStorage splitsStorage,
                             @NonNull SplitChangeProcessor splitChangeProcessor,
@@ -74,14 +75,36 @@ public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
                             @NonNull TelemetryRuntimeProducer telemetryRuntimeProducer,
                             @NonNull BackoffCounter backoffCounter,
                             @Nullable String flagsSpec) {
+        this(splitFetcher,
+                splitsStorage,
+                splitChangeProcessor,
+                ruleBasedSegmentChangeProcessor,
+                ruleBasedSegmentStorage,
+                telemetryRuntimeProducer,
+                backoffCounter,
+                flagsSpec,
+                false);
+    }
+
+    @VisibleForTesting
+    public SplitsSyncHelper(@NonNull HttpFetcher<TargetingRulesChange> splitFetcher,
+                            @NonNull SplitsStorage splitsStorage,
+                            @NonNull SplitChangeProcessor splitChangeProcessor,
+                            @NonNull RuleBasedSegmentChangeProcessor ruleBasedSegmentChangeProcessor,
+                            @NonNull RuleBasedSegmentStorageProducer ruleBasedSegmentStorage,
+                            @NonNull TelemetryRuntimeProducer telemetryRuntimeProducer,
+                            @NonNull BackoffCounter backoffCounter,
+                            @Nullable String flagsSpec,
+                            boolean forBackgroundSync) {
         mSplitFetcher = checkNotNull(splitFetcher);
         mSplitsStorage = checkNotNull(splitsStorage);
         mSplitChangeProcessor = checkNotNull(splitChangeProcessor);
         mRuleBasedSegmentChangeProcessor = checkNotNull(ruleBasedSegmentChangeProcessor);
         mRuleBasedSegmentStorage = checkNotNull(ruleBasedSegmentStorage);
         mTelemetryRuntimeProducer = checkNotNull(telemetryRuntimeProducer);
         mBackoffCounter = checkNotNull(backoffCounter);
-        mFlagsSpec = flagsSpec;
+        String mPreviousSpec = "1.2";
+        mOutdatedSplitProxyHandler = new OutdatedSplitProxyHandler(flagsSpec, mPreviousSpec, forBackgroundSync);
     }
 
     public SplitTaskExecutionInfo sync(SinceChangeNumbers till, int onDemandFetchBackoffMaxRetries) {
@@ -113,6 +136,14 @@ private SplitTaskExecutionInfo sync(SinceChangeNumbers till, boolean clearBefore
                         Collections.singletonMap(SplitTaskExecutionInfo.DO_NOT_RETRY, true));
             }
 
+            if (HttpStatus.isProxyOutdated(httpStatus)) {
+                try {
+                    return handleOutdatedProxy(till, avoidCache, resetChangeNumber, onDemandFetchBackoffMaxRetries);
+                } catch (Exception e1) {
+                    logError("Unexpected while handling outdated proxy" + e1.getLocalizedMessage());
+                }
+            }
+
             return SplitTaskExecutionInfo.error(SplitTaskType.SPLITS_SYNC);
         } catch (Exception e) {
             logError("Unexpected while fetching feature flags" + e.getLocalizedMessage());
@@ -123,6 +154,25 @@ private SplitTaskExecutionInfo sync(SinceChangeNumbers till, boolean clearBefore
         return SplitTaskExecutionInfo.success(SplitTaskType.SPLITS_SYNC);
     }
 
+    private SplitTaskExecutionInfo handleOutdatedProxy(SinceChangeNumbers till, boolean avoidCache, boolean resetChangeNumber, int onDemandFetchBackoffMaxRetries) throws Exception {
+        OutdatedSplitProxyHandler.ProxyHandlingType handle = mOutdatedSplitProxyHandler.handle();
+        switch (handle) {
+            case FALLBACK: {
+                long flagsSince = till.getFlagsSince();
+                SinceChangeNumbers newTill = new SinceChangeNumbers(flagsSince, null);
+                attemptSplitSync(newTill, false, false, CdnByPassType.NONE, false, onDemandFetchBackoffMaxRetries);
+                break;
+            }
+            case RECOVERY: {
+                SinceChangeNumbers newTill = new SinceChangeNumbers(-1, -1L);
+                attemptSplitSync(newTill, true, false, CdnByPassType.NONE, true, onDemandFetchBackoffMaxRetries);
+                break;
+            }
+        }
+
+        return SplitTaskExecutionInfo.success(SplitTaskType.SPLITS_SYNC);
+    }
+
     /**
      * @param targetChangeNumber              target changeNumber
      * @param clearBeforeUpdate whether to clear splits storage before updating it
@@ -140,7 +190,8 @@ private CdnByPassType attemptSplitSync(SinceChangeNumbers targetChangeNumber, bo
             SinceChangeNumbers retrievedChangeNumber = fetchUntil(targetChangeNumber, clearBeforeUpdate, avoidCache, withCdnBypass, resetChangeNumber);
             resetChangeNumber = false;
 
-            if (targetChangeNumber.getFlagsSince() <= retrievedChangeNumber.getFlagsSince() && targetChangeNumber.getRbsSince() <= retrievedChangeNumber.getRbsSince()) {
+            if (targetChangeNumber.getFlagsSince() <= retrievedChangeNumber.getFlagsSince() &&
+                    targetChangeNumber.getRbsSince() != null && retrievedChangeNumber.getRbsSince() != null && targetChangeNumber.getRbsSince() <= retrievedChangeNumber.getRbsSince()) {
                 return CdnByPassType.NONE;
             }
 
@@ -170,7 +221,7 @@ private SinceChangeNumbers fetchUntil(SinceChangeNumbers till, boolean clearBefo
             long changeNumber = (resetChangeNumber) ? -1 : mSplitsStorage.getTill();
             long rbsChangeNumber = (resetChangeNumber) ? -1 : mRuleBasedSegmentStorage.getChangeNumber();
             resetChangeNumber = false;
-            if (newTill.getFlagsSince() < changeNumber && newTill.getRbsSince() < rbsChangeNumber) {
+            if ((newTill.getFlagsSince() < changeNumber) && ((newTill.getRbsSince() == null) || (newTill.getRbsSince() < rbsChangeNumber))) {
                 return new SinceChangeNumbers(changeNumber, rbsChangeNumber);
             }
 
@@ -189,11 +240,14 @@ private SinceChangeNumbers fetchUntil(SinceChangeNumbers till, boolean clearBefo
 
     private TargetingRulesChange fetchSplits(SinceChangeNumbers till, boolean avoidCache, CdnByPassType cdnByPassType) throws HttpFetcherException {
         Map<String, Object> params = new LinkedHashMap<>();
-        if (mFlagsSpec != null && !mFlagsSpec.trim().isEmpty()) {
-            params.put(FLAGS_SPEC_PARAM, mFlagsSpec);
+        String flagsSpec = mOutdatedSplitProxyHandler.getCurrentSpec();
+        if (flagsSpec != null && !flagsSpec.trim().isEmpty()) {
+            params.put(FLAGS_SPEC_PARAM, flagsSpec);
         }
         params.put(SINCE_PARAM, till.getFlagsSince());
-        params.put(RBS_SINCE_PARAM, till.getRbsSince());
+        if (till.getRbsSince() != null) {
+            params.put(RBS_SINCE_PARAM, till.getRbsSince());
+        }
 
         if (cdnByPassType == CdnByPassType.RBS) {
             params.put(TILL_PARAM, till.getRbsSince());
@@ -231,9 +285,10 @@ private void logError(String message) {
 
     public static class SinceChangeNumbers {
         private final long mFlagsSince;
-        private final long mRbsSince;
+        @Nullable
+        private final Long mRbsSince;
 
-        public SinceChangeNumbers(long flagsSince, long rbsSince) {
+        public SinceChangeNumbers(long flagsSince, @Nullable Long rbsSince) {
             mFlagsSince = flagsSince;
             mRbsSince = rbsSince;
         }
@@ -242,15 +297,16 @@ public long getFlagsSince() {
             return mFlagsSince;
         }
 
-        public long getRbsSince() {
+        @Nullable
+        public Long getRbsSince() {
             return mRbsSince;
         }
 
         @Override
         public boolean equals(@Nullable Object obj) {
             return obj instanceof SinceChangeNumbers &&
                     mFlagsSince == ((SinceChangeNumbers) obj).mFlagsSince &&
-                    mRbsSince == ((SinceChangeNumbers) obj).mRbsSince;
+                    (mRbsSince == null && ((SinceChangeNumbers) obj).mRbsSince == null);
         }
 
         @NonNull
diff --git a/src/main/java/io/split/android/client/service/workmanager/splits/SyncHelperProvider.java b/src/main/java/io/split/android/client/service/workmanager/splits/SyncHelperProvider.java
@@ -24,6 +24,7 @@ SplitsSyncHelper provideSplitsSyncHelper(HttpFetcher<TargetingRulesChange> split
                 ruleBasedSegmentChangeProcessor,
                 ruleBasedSegmentStorage,
                 telemetryStorage,
-                mFlagsSpec);
+                mFlagsSpec,
+                true);
     }
 }
diff --git a/src/test/java/io/split/android/client/service/SplitsSyncHelperTest.java b/src/test/java/io/split/android/client/service/SplitsSyncHelperTest.java

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,8 @@ public SplitTaskFactoryImpl(@NonNull SplitClientConfig splitClientConfig,`
`110`	`110`	`mRuleBasedSegmentChangeProcessor,`
`111`	`111`	`ruleBasedSegmentStorageProducer,`
`112`	`112`	`mTelemetryRuntimeProducer,`
`113`		`- flagsSpecFromConfig);`
	`113`	`+ flagsSpecFromConfig,`
	`114`	`+ false);`
`114`	`115`	`}`
`115`	`116`
`116`	`117`	`mFilters = (filters == null) ? new ArrayList<>() : new ArrayList<>(filters.values());`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public static boolean isNotRetryable(Integer code) {`
`52`	`52`	`return isNotRetryable(fromCode(code));`
`53`	`53`	`}`
`54`	`54`
`55`		`- public static boolean isProxyOutdated(Integer code) {`
`56`		`- return fromCode(code) == HttpStatus.INTERNAL_PROXY_OUTDATED;`
	`55`	`+ public static boolean isProxyOutdated(HttpStatus status) {`
	`56`	`+ return status == HttpStatus.INTERNAL_PROXY_OUTDATED;`
`57`	`57`	`}`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ SplitsSyncHelper provideSplitsSyncHelper(HttpFetcher<TargetingRulesChange> split`
`24`	`24`	`ruleBasedSegmentChangeProcessor,`
`25`	`25`	`ruleBasedSegmentStorage,`
`26`	`26`	`telemetryStorage,`
`27`		`- mFlagsSpec);`
	`27`	`+ mFlagsSpec,`
	`28`	`+ true);`
`28`	`29`	`}`
`29`	`30`	`}`