libs/rollback/src/com/android/cts/rollback/lib/RollbackUtils.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.cts.rollback.lib;

 import static com.google.common.truth.Truth.assertThat;

 import android.app.ActivityManager;
 import android.app.AlarmManager;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.VersionedPackage;
 import android.content.rollback.PackageRollbackInfo;
 import android.content.rollback.RollbackInfo;
 import android.content.rollback.RollbackManager;
 import android.util.Log;

 import androidx.test.InstrumentationRegistry;

 import com.android.cts.install.lib.InstallUtils;
 import com.android.cts.install.lib.LocalIntentSender;
 import com.android.cts.install.lib.TestApp;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Predicate;
 import java.util.function.Supplier;

 /**
  * Utilities to facilitate testing rollbacks.
  */
 public class RollbackUtils {

     private static final String TAG = "RollbackTest";

     /**
      * Time between repeated checks in {@link #retry}.
      */
     private static final long RETRY_CHECK_INTERVAL_MILLIS = 500;

     /**
      * Maximum number of checks in {@link #retry} before a timeout occurs.
      */
     private static final long RETRY_MAX_INTERVALS = 20;


     /**
      * Gets the RollbackManager for the instrumentation context.
      */
     public static RollbackManager getRollbackManager() {
         Context context = InstrumentationRegistry.getContext();
         RollbackManager rm = (RollbackManager) context.getSystemService(Context.ROLLBACK_SERVICE);
         if (rm == null) {
             throw new AssertionError("Failed to get RollbackManager");
         }
         return rm;
     }

     /**
      * Returns a rollback for the given rollback Id, if found. Otherwise, returns null.
      */
     private static RollbackInfo getRollbackById(List<RollbackInfo> rollbacks, int rollbackId) {
         for (RollbackInfo rollback :rollbacks) {
             if (rollback.getRollbackId() == rollbackId) {
                 return rollback;
             }
         }
         return null;
     }

     /**
      * Returns an available rollback for the given package name. Returns null
      * if there are no available rollbacks, and throws an assertion if there
      * is more than one.
      */
     public static RollbackInfo getAvailableRollback(String packageName) {
         RollbackManager rm = getRollbackManager();
         return getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), packageName);
     }

     /**
      * Returns a recently committed rollback for the given package name. Returns null
      * if there are no available rollbacks, and throws an assertion if there
      * is more than one.
      */
     public static RollbackInfo getCommittedRollback(String packageName) {
         RollbackManager rm = getRollbackManager();
         return getUniqueRollbackInfoForPackage(rm.getRecentlyCommittedRollbacks(), packageName);
     }

     /**
      * Returns a recently committed rollback for the given rollback Id.
      * Returns null if no committed rollback with a matching Id was found.
      */
     public static RollbackInfo getCommittedRollbackById(int rollbackId) {
         RollbackManager rm = getRollbackManager();
         return getRollbackById(rm.getRecentlyCommittedRollbacks(), rollbackId);
     }

     /**
      * Commit the given rollback. This method won't return until the committed session is made
      * ready or failed. The caller is safe to immediately reboot the device right after the call.
      * @throws AssertionError if the rollback fails.
      */
     public static void rollback(int rollbackId, TestApp... causePackages)
             throws InterruptedException {
         List<VersionedPackage> causes = new ArrayList<>();
         for (TestApp cause : causePackages) {
             causes.add(cause.getVersionedPackage());
         }

         RollbackManager rm = getRollbackManager();
         LocalIntentSender sender = new LocalIntentSender();
         rm.commitRollback(rollbackId, causes, sender.getIntentSender());
         Intent result = sender.getResult();
         int status = result.getIntExtra(RollbackManager.EXTRA_STATUS,
                 RollbackManager.STATUS_FAILURE);
         if (status != RollbackManager.STATUS_SUCCESS) {
             String message = result.getStringExtra(RollbackManager.EXTRA_STATUS_MESSAGE);
             throw new AssertionError(message);
         }

         RollbackInfo committed = getCommittedRollbackById(rollbackId);
         if (committed.isStaged()) {
             InstallUtils.waitForSessionReady(committed.getCommittedSessionId());
         }
     }

     /**
      * Forwards the device clock time by {@code offsetMillis}.
      */
     public static void forwardTimeBy(long offsetMillis) {
         setTime(System.currentTimeMillis() + offsetMillis);
         Log.i(TAG, "Forwarded time on device by " + offsetMillis + " millis");
     }

     /**
      * Returns the RollbackInfo with a given package in the list of rollbacks.
      * Throws an assertion failure if there is more than one such rollback
      * info. Returns null if there are no such rollback infos.
      */
     public static RollbackInfo getUniqueRollbackInfoForPackage(List<RollbackInfo> rollbacks,
             String packageName) {
         RollbackInfo found = null;
         for (RollbackInfo rollback : rollbacks) {
             for (PackageRollbackInfo info : rollback.getPackages()) {
                 if (packageName.equals(info.getPackageName())) {
                     assertThat(found).isNull();
                     found = rollback;
                     break;
                 }
             }
         }
         return found;
     }

     /**
      * Returns an available rollback matching the specified package name. If no such rollback is
      * available, getAvailableRollbacks is called repeatedly until one becomes available. An
      * assertion is raised if this does not occur after a certain number of checks.
      */
     public static RollbackInfo waitForAvailableRollback(String packageName)
             throws InterruptedException {
         return retry(() -> getAvailableRollback(packageName),
                 Objects::nonNull, "Rollback did not become available.");
     }

     /**
      * If there is no available rollback matching the specified package name, this returns
      * immediately. If such a rollback is available, getAvailableRollbacks is called repeatedly
      * until it is no longer available. An assertion is raised if this does not occur after a
      * certain number of checks.
      */
     public static void waitForUnavailableRollback(String packageName) throws InterruptedException {
         retry(() -> getAvailableRollback(packageName), Objects::isNull,
                 "Rollback did not become unavailable");
     }

     private static boolean hasRollbackInclude(List<RollbackInfo> rollbacks, String packageName) {
         return rollbacks.stream().anyMatch(
                 ri -> ri.getPackages().stream().anyMatch(
                         pri -> packageName.equals(pri.getPackageName())));
     }

     /**
      * Retries until all rollbacks including {@code packageName} are gone. An assertion is raised if
      * this does not occur after a certain number of checks.
      */
     public static void waitForRollbackGone(
             Supplier<List<RollbackInfo>> supplier, String packageName) throws InterruptedException {
         retry(supplier, rollbacks -> !hasRollbackInclude(rollbacks, packageName),
                 "Rollback containing " + packageName + " did not go away");
     }

     private static <T> T retry(Supplier<T> supplier, Predicate<T> predicate, String message)
             throws InterruptedException {
         for (int i = 0; i < RETRY_MAX_INTERVALS; i++) {
             T result = supplier.get();
             if (predicate.test(result)) {
                 return result;
             }
             Thread.sleep(RETRY_CHECK_INTERVAL_MILLIS);
         }
         throw new AssertionError(message);
     }

     /**
      * Send broadcast to crash {@code packageName} {@code count} times. If {@code count} is at least
      * {@link PackageWatchdog#TRIGGER_FAILURE_COUNT}, watchdog crash detection will be triggered.
      */
     public static void sendCrashBroadcast(String packageName,
             int count) throws InterruptedException, IOException {
         for (int i = 0; i < count; ++i) {
             launchPackageForCrash(packageName);
         }
     }

     private static void setTime(long millis) {
         Context context = InstrumentationRegistry.getContext();
         AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
         am.setTime(millis);
     }

     /**
      * Launches {@code packageName} with {@link Intent#ACTION_MAIN} and
      * waits for a CRASH broadcast from the launched app.
      */
     private static void launchPackageForCrash(String packageName)
             throws InterruptedException, IOException {
         // Force stop the package before launching it to make sure it isn't
         // stuck in a non-launchable state. And wait a second afterwards to
         // avoid interfering with when we launch the app.
         Log.i(TAG, "Force stopping " + packageName);
         Context context = InstrumentationRegistry.getContext();
         ActivityManager am = context.getSystemService(ActivityManager.class);
         am.forceStopPackage(packageName);
         Thread.sleep(1000);

         // Register a receiver to listen for the CRASH broadcast.
         CountDownLatch latch = new CountDownLatch(1);
         IntentFilter crashFilter = new IntentFilter();
         crashFilter.addAction("com.android.tests.rollback.CRASH");
         crashFilter.addCategory(Intent.CATEGORY_DEFAULT);
         BroadcastReceiver crashReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 Log.i(TAG, "Received CRASH broadcast from " + packageName);
                 latch.countDown();
             }
         };
         context.registerReceiver(crashReceiver, crashFilter);

         // Launch the app.
         Intent intent = new Intent(Intent.ACTION_MAIN);
         intent.setPackage(packageName);
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         intent.addCategory(Intent.CATEGORY_LAUNCHER);
         Log.i(TAG, "Launching " + packageName + " with " + intent);
         context.startActivity(intent);

         Log.i(TAG, "Waiting for CRASH broadcast from " + packageName);
         latch.await();

         context.unregisterReceiver(crashReceiver);

         // Sleep long enough for packagewatchdog to be notified of crash
         Thread.sleep(1000);
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.cts.rollback.lib;

	import static com.google.common.truth.Truth.assertThat;

	import android.app.ActivityManager;
	import android.app.AlarmManager;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.pm.VersionedPackage;
	import android.content.rollback.PackageRollbackInfo;
	import android.content.rollback.RollbackInfo;
	import android.content.rollback.RollbackManager;
	import android.util.Log;

	import androidx.test.InstrumentationRegistry;

	import com.android.cts.install.lib.InstallUtils;
	import com.android.cts.install.lib.LocalIntentSender;
	import com.android.cts.install.lib.TestApp;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Objects;
	import java.util.concurrent.CountDownLatch;
	import java.util.function.Predicate;
	import java.util.function.Supplier;

	/**
	* Utilities to facilitate testing rollbacks.
	*/
	public class RollbackUtils {

	private static final String TAG = "RollbackTest";

	/**
	* Time between repeated checks in {@link #retry}.
	*/
	private static final long RETRY_CHECK_INTERVAL_MILLIS = 500;

	/**
	* Maximum number of checks in {@link #retry} before a timeout occurs.
	*/
	private static final long RETRY_MAX_INTERVALS = 20;


	/**
	* Gets the RollbackManager for the instrumentation context.
	*/
	public static RollbackManager getRollbackManager() {
	Context context = InstrumentationRegistry.getContext();
	RollbackManager rm = (RollbackManager) context.getSystemService(Context.ROLLBACK_SERVICE);
	if (rm == null) {
	throw new AssertionError("Failed to get RollbackManager");
	}
	return rm;
	}

	/**
	* Returns a rollback for the given rollback Id, if found. Otherwise, returns null.
	*/
	private static RollbackInfo getRollbackById(List<RollbackInfo> rollbacks, int rollbackId) {
	for (RollbackInfo rollback :rollbacks) {
	if (rollback.getRollbackId() == rollbackId) {
	return rollback;
	}
	}
	return null;
	}

	/**
	* Returns an available rollback for the given package name. Returns null
	* if there are no available rollbacks, and throws an assertion if there
	* is more than one.
	*/
	public static RollbackInfo getAvailableRollback(String packageName) {
	RollbackManager rm = getRollbackManager();
	return getUniqueRollbackInfoForPackage(rm.getAvailableRollbacks(), packageName);
	}

	/**
	* Returns a recently committed rollback for the given package name. Returns null
	* if there are no available rollbacks, and throws an assertion if there
	* is more than one.
	*/
	public static RollbackInfo getCommittedRollback(String packageName) {
	RollbackManager rm = getRollbackManager();
	return getUniqueRollbackInfoForPackage(rm.getRecentlyCommittedRollbacks(), packageName);
	}

	/**
	* Returns a recently committed rollback for the given rollback Id.
	* Returns null if no committed rollback with a matching Id was found.
	*/
	public static RollbackInfo getCommittedRollbackById(int rollbackId) {
	RollbackManager rm = getRollbackManager();
	return getRollbackById(rm.getRecentlyCommittedRollbacks(), rollbackId);
	}

	/**
	* Commit the given rollback. This method won't return until the committed session is made
	* ready or failed. The caller is safe to immediately reboot the device right after the call.
	* @throws AssertionError if the rollback fails.
	*/
	public static void rollback(int rollbackId, TestApp... causePackages)
	throws InterruptedException {
	List<VersionedPackage> causes = new ArrayList<>();
	for (TestApp cause : causePackages) {
	causes.add(cause.getVersionedPackage());
	}

	RollbackManager rm = getRollbackManager();
	LocalIntentSender sender = new LocalIntentSender();
	rm.commitRollback(rollbackId, causes, sender.getIntentSender());
	Intent result = sender.getResult();
	int status = result.getIntExtra(RollbackManager.EXTRA_STATUS,
	RollbackManager.STATUS_FAILURE);
	if (status != RollbackManager.STATUS_SUCCESS) {
	String message = result.getStringExtra(RollbackManager.EXTRA_STATUS_MESSAGE);
	throw new AssertionError(message);
	}

	RollbackInfo committed = getCommittedRollbackById(rollbackId);
	if (committed.isStaged()) {
	InstallUtils.waitForSessionReady(committed.getCommittedSessionId());
	}
	}

	/**
	* Forwards the device clock time by {@code offsetMillis}.
	*/
	public static void forwardTimeBy(long offsetMillis) {
	setTime(System.currentTimeMillis() + offsetMillis);
	Log.i(TAG, "Forwarded time on device by " + offsetMillis + " millis");
	}

	/**
	* Returns the RollbackInfo with a given package in the list of rollbacks.
	* Throws an assertion failure if there is more than one such rollback
	* info. Returns null if there are no such rollback infos.
	*/
	public static RollbackInfo getUniqueRollbackInfoForPackage(List<RollbackInfo> rollbacks,
	String packageName) {
	RollbackInfo found = null;
	for (RollbackInfo rollback : rollbacks) {
	for (PackageRollbackInfo info : rollback.getPackages()) {
	if (packageName.equals(info.getPackageName())) {
	assertThat(found).isNull();
	found = rollback;
	break;
	}
	}
	}
	return found;
	}

	/**
	* Returns an available rollback matching the specified package name. If no such rollback is
	* available, getAvailableRollbacks is called repeatedly until one becomes available. An
	* assertion is raised if this does not occur after a certain number of checks.
	*/
	public static RollbackInfo waitForAvailableRollback(String packageName)
	throws InterruptedException {
	return retry(() -> getAvailableRollback(packageName),
	Objects::nonNull, "Rollback did not become available.");
	}

	/**
	* If there is no available rollback matching the specified package name, this returns
	* immediately. If such a rollback is available, getAvailableRollbacks is called repeatedly
	* until it is no longer available. An assertion is raised if this does not occur after a
	* certain number of checks.
	*/
	public static void waitForUnavailableRollback(String packageName) throws InterruptedException {
	retry(() -> getAvailableRollback(packageName), Objects::isNull,
	"Rollback did not become unavailable");
	}

	private static boolean hasRollbackInclude(List<RollbackInfo> rollbacks, String packageName) {
	return rollbacks.stream().anyMatch(
	ri -> ri.getPackages().stream().anyMatch(
	pri -> packageName.equals(pri.getPackageName())));
	}

	/**
	* Retries until all rollbacks including {@code packageName} are gone. An assertion is raised if
	* this does not occur after a certain number of checks.
	*/
	public static void waitForRollbackGone(
	Supplier<List<RollbackInfo>> supplier, String packageName) throws InterruptedException {
	retry(supplier, rollbacks -> !hasRollbackInclude(rollbacks, packageName),
	"Rollback containing " + packageName + " did not go away");
	}

	private static <T> T retry(Supplier<T> supplier, Predicate<T> predicate, String message)
	throws InterruptedException {
	for (int i = 0; i < RETRY_MAX_INTERVALS; i++) {
	T result = supplier.get();
	if (predicate.test(result)) {
	return result;
	}
	Thread.sleep(RETRY_CHECK_INTERVAL_MILLIS);
	}
	throw new AssertionError(message);
	}

	/**
	* Send broadcast to crash {@code packageName} {@code count} times. If {@code count} is at least
	* {@link PackageWatchdog#TRIGGER_FAILURE_COUNT}, watchdog crash detection will be triggered.
	*/
	public static void sendCrashBroadcast(String packageName,
	int count) throws InterruptedException, IOException {
	for (int i = 0; i < count; ++i) {
	launchPackageForCrash(packageName);
	}
	}

	private static void setTime(long millis) {
	Context context = InstrumentationRegistry.getContext();
	AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
	am.setTime(millis);
	}

	/**
	* Launches {@code packageName} with {@link Intent#ACTION_MAIN} and
	* waits for a CRASH broadcast from the launched app.
	*/
	private static void launchPackageForCrash(String packageName)
	throws InterruptedException, IOException {
	// Force stop the package before launching it to make sure it isn't
	// stuck in a non-launchable state. And wait a second afterwards to
	// avoid interfering with when we launch the app.
	Log.i(TAG, "Force stopping " + packageName);
	Context context = InstrumentationRegistry.getContext();
	ActivityManager am = context.getSystemService(ActivityManager.class);
	am.forceStopPackage(packageName);
	Thread.sleep(1000);

	// Register a receiver to listen for the CRASH broadcast.
	CountDownLatch latch = new CountDownLatch(1);
	IntentFilter crashFilter = new IntentFilter();
	crashFilter.addAction("com.android.tests.rollback.CRASH");
	crashFilter.addCategory(Intent.CATEGORY_DEFAULT);
	BroadcastReceiver crashReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	Log.i(TAG, "Received CRASH broadcast from " + packageName);
	latch.countDown();
	}
	};
	context.registerReceiver(crashReceiver, crashFilter);

	// Launch the app.
	Intent intent = new Intent(Intent.ACTION_MAIN);
	intent.setPackage(packageName);
	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
	intent.addCategory(Intent.CATEGORY_LAUNCHER);
	Log.i(TAG, "Launching " + packageName + " with " + intent);
	context.startActivity(intent);

	Log.i(TAG, "Waiting for CRASH broadcast from " + packageName);
	latch.await();

	context.unregisterReceiver(crashReceiver);

	// Sleep long enough for packagewatchdog to be notified of crash
	Thread.sleep(1000);
	}
	}