Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename RollbackData to Rollback.

Browse Source 
Because "Data" doesn't add anything useful to the name.

Also prefer the variable name "rollback" over "data" and "rd" for
instances of Rollback.

Test: builds.
Change-Id: Ibaa3326660345a763c67c573368ba1da11c0a830
Merged-In: I5ae3866753d6badcdf019525b40522937568dee5
This commit is contained in:
Richard Uhler
2019-07-19 14:55:01 +01:00
committed by Bill Lin
parent 87a504d1fc
commit 91fc4db14e
5 changed files with 251 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
services/core/java/com/android/server/rollback/AppDataRollbackHelper.java
View File

@@ -98,14 +98,14 @@ public class AppDataRollbackHelper {
final IntArray pendingBackups = packageRollbackInfo.getPendingBackups();
final List<RestoreInfo> pendingRestores = packageRollbackInfo.getPendingRestores();
boolean changedRollbackData = false;
boolean changedRollback = false;
// If we still have a userdata backup pending for this user, it implies that the user
// hasn't unlocked their device between the point of backup and the point of restore,
// so the data cannot have changed. We simply skip restoring CE data in this case.
if (pendingBackups != null && pendingBackups.indexOf(userId) != -1) {
pendingBackups.remove(pendingBackups.indexOf(userId));
changedRollbackData = true;
changedRollback = true;
} else {
// There's no pending CE backup for this user, which means that we successfully
// managed to backup data for the user, which means we seek to restore it
@@ -113,7 +113,7 @@ public class AppDataRollbackHelper {
// We've encountered a user that hasn't unlocked on a FBE device, so we can't
// copy across app user data until the user unlocks their device.
pendingRestores.add(new RestoreInfo(userId, appId, seInfo));
changedRollbackData = true;
changedRollback = true;
} else {
// This user has unlocked, we can proceed to restore both CE and DE data.
storageFlags = storageFlags | Installer.FLAG_STORAGE_CE;
@@ -128,7 +128,7 @@ public class AppDataRollbackHelper {
+ packageRollbackInfo.getPackageName(), ie);
}
return changedRollbackData;
return changedRollback;
}
/**
@@ -160,29 +160,29 @@ public class AppDataRollbackHelper {
* Packages pending backup for the given user are added to {@code pendingBackupPackages} along
* with their corresponding {@code PackageRollbackInfo}.
*
* @return the list of {@code RollbackData} that has pending backups. Note that some of the
* @return the list of rollbacks that have pending backups. Note that some of the
* backups won't be performed, because they might be counteracted by pending restores.
*/
private static List<RollbackData> computePendingBackups(int userId,
private static List<Rollback> computePendingBackups(int userId,
Map<String, PackageRollbackInfo> pendingBackupPackages,
List<RollbackData> rollbacks) {
List<RollbackData> rd = new ArrayList<>();
List<Rollback> rollbacks) {
List<Rollback> rollbacksWithPendingBackups = new ArrayList<>();
for (RollbackData data : rollbacks) {
for (PackageRollbackInfo info : data.info.getPackages()) {
for (Rollback rollback : rollbacks) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
final IntArray pendingBackupUsers = info.getPendingBackups();
if (pendingBackupUsers != null) {
final int idx = pendingBackupUsers.indexOf(userId);
if (idx != -1) {
pendingBackupPackages.put(info.getPackageName(), info);
if (rd.indexOf(data) == -1) {
rd.add(data);
if (rollbacksWithPendingBackups.indexOf(rollback) == -1) {
rollbacksWithPendingBackups.add(rollback);
}
}
}
}
}
return rd;
return rollbacksWithPendingBackups;
}
/**
@@ -190,45 +190,45 @@ public class AppDataRollbackHelper {
* Packages pending restore are added to {@code pendingRestores} along with their corresponding
* {@code PackageRollbackInfo}.
*
* @return the list of {@code RollbackData} that has pending restores. Note that some of the
* @return the list of rollbacks that have pending restores. Note that some of the
* restores won't be performed, because they might be counteracted by pending backups.
*/
private static List<RollbackData> computePendingRestores(int userId,
private static List<Rollback> computePendingRestores(int userId,
Map<String, PackageRollbackInfo> pendingRestorePackages,
List<RollbackData> rollbacks) {
List<RollbackData> rd = new ArrayList<>();
List<Rollback> rollbacks) {
List<Rollback> rollbacksWithPendingRestores = new ArrayList<>();
for (RollbackData data : rollbacks) {
for (PackageRollbackInfo info : data.info.getPackages()) {
for (Rollback rollback : rollbacks) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
final RestoreInfo ri = info.getRestoreInfo(userId);
if (ri != null) {
pendingRestorePackages.put(info.getPackageName(), info);
if (rd.indexOf(data) == -1) {
rd.add(data);
if (rollbacksWithPendingRestores.indexOf(rollback) == -1) {
rollbacksWithPendingRestores.add(rollback);
}
}
}
}
return rd;
return rollbacksWithPendingRestores;
}
/**
* Commits the list of pending backups and restores for a given {@code userId}. For the pending
* backups updates corresponding {@code changedRollbackData} with a mapping from {@code userId}
* to a inode of theirs CE user data snapshot.
* Commits the list of pending backups and restores for a given {@code userId}. For rollbacks
* with pending backups, updates the {@code Rollback} instance with a mapping from
* {@code userId} to inode of the CE user data snapshot.
*
* @return the set of {@code RollbackData} that have been changed and should be stored on disk.
* @return the set of rollbacks with changes that should be stored on disk.
*/
public Set<RollbackData> commitPendingBackupAndRestoreForUser(int userId,
List<RollbackData> rollbacks) {
public Set<Rollback> commitPendingBackupAndRestoreForUser(int userId,
List<Rollback> rollbacks) {
final Map<String, PackageRollbackInfo> pendingBackupPackages = new HashMap<>();
final List<RollbackData> pendingBackups = computePendingBackups(userId,
final List<Rollback> pendingBackups = computePendingBackups(userId,
pendingBackupPackages, rollbacks);
final Map<String, PackageRollbackInfo> pendingRestorePackages = new HashMap<>();
final List<RollbackData> pendingRestores = computePendingRestores(userId,
final List<Rollback> pendingRestores = computePendingRestores(userId,
pendingRestorePackages, rollbacks);
// First remove unnecessary backups, i.e. when user did not unlock their phone between the
@@ -248,14 +248,15 @@ public class AppDataRollbackHelper {
}
if (!pendingBackupPackages.isEmpty()) {
for (RollbackData data : pendingBackups) {
for (PackageRollbackInfo info : data.info.getPackages()) {
for (Rollback rollback : pendingBackups) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
final IntArray pendingBackupUsers = info.getPendingBackups();
final int idx = pendingBackupUsers.indexOf(userId);
if (idx != -1) {
try {
long ceSnapshotInode = mInstaller.snapshotAppData(info.getPackageName(),
userId, data.info.getRollbackId(), Installer.FLAG_STORAGE_CE);
userId, rollback.info.getRollbackId(),
Installer.FLAG_STORAGE_CE);
info.putCeSnapshotInode(userId, ceSnapshotInode);
pendingBackupUsers.remove(idx);
} catch (InstallerException ie) {
@@ -269,13 +270,13 @@ public class AppDataRollbackHelper {
}
if (!pendingRestorePackages.isEmpty()) {
for (RollbackData data : pendingRestores) {
for (PackageRollbackInfo info : data.info.getPackages()) {
for (Rollback rollback : pendingRestores) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
final RestoreInfo ri = info.getRestoreInfo(userId);
if (ri != null) {
try {
mInstaller.restoreAppDataSnapshot(info.getPackageName(), ri.appId,
ri.seInfo, userId, data.info.getRollbackId(),
ri.seInfo, userId, rollback.info.getRollbackId(),
Installer.FLAG_STORAGE_CE);
info.removeRestoreInfo(ri);
} catch (InstallerException ie) {
@@ -287,7 +288,7 @@ public class AppDataRollbackHelper {
}
}
final Set<RollbackData> changed = new HashSet<>(pendingBackups);
final Set<Rollback> changed = new HashSet<>(pendingBackups);
changed.addAll(pendingRestores);
return changed;
}

22
services/core/java/com/android/server/rollback/RollbackData.java → services/core/java/com/android/server/rollback/Rollback.java
View File

@@ -32,7 +32,7 @@ import java.util.ArrayList;
* Information about a rollback available for a set of atomically installed
* packages.
*/
class RollbackData {
class Rollback {
@IntDef(flag = true, prefix = { "ROLLBACK_STATE_" }, value = {
ROLLBACK_STATE_ENABLING,
ROLLBACK_STATE_AVAILABLE,
@@ -102,13 +102,13 @@ class RollbackData {
public boolean restoreUserDataInProgress = false;
/**
* Constructs a new, empty RollbackData instance.
* Constructs a new, empty Rollback instance.
*
* @param rollbackId the id of the rollback.
* @param backupDir the directory where the rollback data is stored.
* @param stagedSessionId the session id if this is a staged rollback, -1 otherwise.
*/
RollbackData(int rollbackId, File backupDir, int stagedSessionId) {
Rollback(int rollbackId, File backupDir, int stagedSessionId) {
this.info = new RollbackInfo(rollbackId,
/* packages */ new ArrayList<>(),
/* isStaged */ stagedSessionId != -1,
@@ -121,9 +121,9 @@ class RollbackData {
}
/**
* Constructs a RollbackData instance with full rollback data information.
* Constructs a pre-populated Rollback instance.
*/
RollbackData(RollbackInfo info, File backupDir, Instant timestamp, int stagedSessionId,
Rollback(RollbackInfo info, File backupDir, Instant timestamp, int stagedSessionId,
@RollbackState int state, int apkSessionId, boolean restoreUserDataInProgress) {
this.info = info;
this.backupDir = backupDir;
@@ -143,9 +143,9 @@ class RollbackData {
static String rollbackStateToString(@RollbackState int state) {
switch (state) {
case RollbackData.ROLLBACK_STATE_ENABLING: return "enabling";
case RollbackData.ROLLBACK_STATE_AVAILABLE: return "available";
case RollbackData.ROLLBACK_STATE_COMMITTED: return "committed";
case Rollback.ROLLBACK_STATE_ENABLING: return "enabling";
case Rollback.ROLLBACK_STATE_AVAILABLE: return "available";
case Rollback.ROLLBACK_STATE_COMMITTED: return "committed";
}
throw new AssertionError("Invalid rollback state: " + state);
}
@@ -153,9 +153,9 @@ class RollbackData {
static @RollbackState int rollbackStateFromString(String state)
throws ParseException {
switch (state) {
case "enabling": return RollbackData.ROLLBACK_STATE_ENABLING;
case "available": return RollbackData.ROLLBACK_STATE_AVAILABLE;
case "committed": return RollbackData.ROLLBACK_STATE_COMMITTED;
case "enabling": return Rollback.ROLLBACK_STATE_ENABLING;
case "available": return Rollback.ROLLBACK_STATE_AVAILABLE;
case "committed": return Rollback.ROLLBACK_STATE_COMMITTED;
}
throw new ParseException("Invalid rollback state: " + state, 0);
}

324
services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
View File

@@ -110,13 +110,13 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
@GuardedBy("mLock")
private final SparseBooleanArray mAllocatedRollbackIds = new SparseBooleanArray();
// Package rollback data for rollbacks we are in the process of enabling.
// Rollbacks we are in the process of enabling.
@GuardedBy("mLock")
private final Set<NewRollback> mNewRollbacks = new ArraySet<>();
// The list of all rollbacks, including available and committed rollbacks.
@GuardedBy("mLock")
private final List<RollbackData> mRollbacks;
private final List<Rollback> mRollbacks;
private final RollbackStore mRollbackStore;
@@ -127,7 +127,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
private final AppDataRollbackHelper mAppDataRollbackHelper;
// This field stores the difference in Millis between the uptime (millis since device
// has booted) and current time (device wall clock) - it's used to update rollback data
// has booted) and current time (device wall clock) - it's used to update rollback
// timestamps when the time is changed, by the user or by change of timezone.
// No need for guarding with lock because value is only accessed in handler thread.
private long mRelativeBootTime = calculateRelativeBootTime();
@@ -146,9 +146,9 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// Load rollback data from device storage.
synchronized (mLock) {
mRollbacks = mRollbackStore.loadAllRollbackData();
for (RollbackData data : mRollbacks) {
mAllocatedRollbackIds.put(data.info.getRollbackId(), true);
mRollbacks = mRollbackStore.loadRollbacks();
for (Rollback rollback : mRollbacks) {
mAllocatedRollbackIds.put(rollback.info.getRollbackId(), true);
}
}
@@ -301,9 +301,9 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
synchronized (mLock) {
List<RollbackInfo> rollbacks = new ArrayList<>();
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.state == RollbackData.ROLLBACK_STATE_AVAILABLE) {
rollbacks.add(data.info);
Rollback rollback = mRollbacks.get(i);
if (rollback.state == Rollback.ROLLBACK_STATE_AVAILABLE) {
rollbacks.add(rollback.info);
}
}
return new ParceledListSlice<>(rollbacks);
@@ -317,9 +317,9 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
synchronized (mLock) {
List<RollbackInfo> rollbacks = new ArrayList<>();
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.state == RollbackData.ROLLBACK_STATE_COMMITTED) {
rollbacks.add(data.info);
Rollback rollback = mRollbacks.get(i);
if (rollback.state == Rollback.ROLLBACK_STATE_COMMITTED) {
rollbacks.add(rollback.info);
}
}
return new ParceledListSlice<>(rollbacks);
@@ -349,11 +349,11 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
final long timeDifference = mRelativeBootTime - oldRelativeBootTime;
synchronized (mLock) {
Iterator<RollbackData> iter = mRollbacks.iterator();
Iterator<Rollback> iter = mRollbacks.iterator();
while (iter.hasNext()) {
RollbackData data = iter.next();
data.timestamp = data.timestamp.plusMillis(timeDifference);
saveRollbackData(data);
Rollback rollback = iter.next();
rollback.timestamp = rollback.timestamp.plusMillis(timeDifference);
saveRollback(rollback);
}
}
}
@@ -377,8 +377,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
String callerPackageName, IntentSender statusReceiver) {
Slog.i(TAG, "Initiating rollback");
RollbackData data = getRollbackForId(rollbackId);
if (data == null || data.state != RollbackData.ROLLBACK_STATE_AVAILABLE) {
Rollback rollback = getRollbackForId(rollbackId);
if (rollback == null || rollback.state != Rollback.ROLLBACK_STATE_AVAILABLE) {
sendFailure(statusReceiver, RollbackManager.STATUS_FAILURE_ROLLBACK_UNAVAILABLE,
"Rollback unavailable");
return;
@@ -402,14 +402,14 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
PackageInstaller.SessionParams.MODE_FULL_INSTALL);
parentParams.setRequestDowngrade(true);
parentParams.setMultiPackage();
if (data.isStaged()) {
if (rollback.isStaged()) {
parentParams.setStaged();
}
int parentSessionId = packageInstaller.createSession(parentParams);
PackageInstaller.Session parentSession = packageInstaller.openSession(parentSessionId);
for (PackageRollbackInfo info : data.info.getPackages()) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
PackageInstaller.SessionParams.MODE_FULL_INSTALL);
// TODO: We can't get the installerPackageName for apex
@@ -424,7 +424,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
params.setRequestDowngrade(true);
params.setRequiredInstalledVersionCode(
info.getVersionRolledBackFrom().getLongVersionCode());
if (data.isStaged()) {
if (rollback.isStaged()) {
params.setStaged();
}
if (info.isApex()) {
@@ -433,7 +433,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
int sessionId = packageInstaller.createSession(params);
PackageInstaller.Session session = packageInstaller.openSession(sessionId);
File[] packageCodePaths = RollbackStore.getPackageCodePaths(
data, info.getPackageName());
rollback, info.getPackageName());
if (packageCodePaths == null) {
sendFailure(statusReceiver, RollbackManager.STATUS_FAILURE,
"Backup copy of package inaccessible");
@@ -474,8 +474,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// TODO: Could this cause a rollback to be
// resurrected if it should otherwise have
// expired by now?
data.state = RollbackData.ROLLBACK_STATE_AVAILABLE;
data.restoreUserDataInProgress = false;
rollback.state = Rollback.ROLLBACK_STATE_AVAILABLE;
rollback.restoreUserDataInProgress = false;
}
sendFailure(statusReceiver, RollbackManager.STATUS_FAILURE_INSTALL,
"Rollback downgrade install failed: "
@@ -485,17 +485,17 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
synchronized (mLock) {
if (!data.isStaged()) {
if (!rollback.isStaged()) {
// All calls to restoreUserData should have
// completed by now for a non-staged install.
data.restoreUserDataInProgress = false;
rollback.restoreUserDataInProgress = false;
}
data.info.setCommittedSessionId(parentSessionId);
data.info.getCausePackages().addAll(causePackages);
rollback.info.setCommittedSessionId(parentSessionId);
rollback.info.getCausePackages().addAll(causePackages);
}
mRollbackStore.deletePackageCodePaths(data);
saveRollbackData(data);
mRollbackStore.deletePackageCodePaths(rollback);
saveRollback(rollback);
sendSuccess(statusReceiver);
@@ -510,8 +510,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
);
synchronized (mLock) {
data.state = RollbackData.ROLLBACK_STATE_COMMITTED;
data.restoreUserDataInProgress = true;
rollback.state = Rollback.ROLLBACK_STATE_COMMITTED;
rollback.restoreUserDataInProgress = true;
}
parentSession.commit(receiver.getIntentSender());
} catch (IOException e) {
@@ -533,7 +533,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
updateRollbackLifetimeDurationInMillis();
synchronized (mLock) {
mRollbacks.clear();
mRollbacks.addAll(mRollbackStore.loadAllRollbackData());
mRollbacks.addAll(mRollbackStore.loadRollbacks());
}
latch.countDown();
});
@@ -551,13 +551,13 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
Manifest.permission.TEST_MANAGE_ROLLBACKS,
"expireRollbackForPackage");
synchronized (mLock) {
Iterator<RollbackData> iter = mRollbacks.iterator();
Iterator<Rollback> iter = mRollbacks.iterator();
while (iter.hasNext()) {
RollbackData data = iter.next();
for (PackageRollbackInfo info : data.info.getPackages()) {
Rollback rollback = iter.next();
for (PackageRollbackInfo info : rollback.info.getPackages()) {
if (info.getPackageName().equals(packageName)) {
iter.remove();
deleteRollback(data);
deleteRollback(rollback);
break;
}
}
@@ -581,16 +581,16 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
void onUnlockUser(int userId) {
getHandler().post(() -> {
final List<RollbackData> rollbacks;
final List<Rollback> rollbacks;
synchronized (mLock) {
rollbacks = new ArrayList<>(mRollbacks);
}
final Set<RollbackData> changed =
final Set<Rollback> changed =
mAppDataRollbackHelper.commitPendingBackupAndRestoreForUser(userId, rollbacks);
for (RollbackData rd : changed) {
saveRollbackData(rd);
for (Rollback rollback : changed) {
saveRollback(rollback);
}
});
}
@@ -613,19 +613,19 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
getHandler().post(() -> {
// Check to see if any rollback-enabled staged sessions or staged
// rollback sessions been applied.
List<RollbackData> enabling = new ArrayList<>();
List<RollbackData> restoreInProgress = new ArrayList<>();
List<Rollback> enabling = new ArrayList<>();
List<Rollback> restoreInProgress = new ArrayList<>();
Set<String> apexPackageNames = new HashSet<>();
synchronized (mLock) {
for (RollbackData data : mRollbacks) {
if (data.isStaged()) {
if (data.state == RollbackData.ROLLBACK_STATE_ENABLING) {
enabling.add(data);
} else if (data.restoreUserDataInProgress) {
restoreInProgress.add(data);
for (Rollback rollback : mRollbacks) {
if (rollback.isStaged()) {
if (rollback.state == Rollback.ROLLBACK_STATE_ENABLING) {
enabling.add(rollback);
} else if (rollback.restoreUserDataInProgress) {
restoreInProgress.add(rollback);
}
for (PackageRollbackInfo info : data.info.getPackages()) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
if (info.isApex()) {
apexPackageNames.add(info.getPackageName());
}
@@ -634,32 +634,32 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
}
for (RollbackData data : enabling) {
for (Rollback rollback : enabling) {
PackageInstaller installer = mContext.getPackageManager().getPackageInstaller();
PackageInstaller.SessionInfo session = installer.getSessionInfo(
data.stagedSessionId);
rollback.stagedSessionId);
if (session == null || session.isStagedSessionFailed()) {
// TODO: Do we need to remove this from
// mRollbacks, or is it okay to leave as
// unavailable until the next reboot when it will go
// away on its own?
deleteRollback(data);
deleteRollback(rollback);
} else if (session.isStagedSessionApplied()) {
makeRollbackAvailable(data);
makeRollbackAvailable(rollback);
}
}
for (RollbackData data : restoreInProgress) {
for (Rollback rollback : restoreInProgress) {
PackageInstaller installer = mContext.getPackageManager().getPackageInstaller();
PackageInstaller.SessionInfo session = installer.getSessionInfo(
data.stagedSessionId);
rollback.stagedSessionId);
// TODO: What if session is null?
if (session != null) {
if (session.isStagedSessionApplied() || session.isStagedSessionFailed()) {
synchronized (mLock) {
data.restoreUserDataInProgress = false;
rollback.restoreUserDataInProgress = false;
}
saveRollbackData(data);
saveRollback(rollback);
}
}
}
@@ -686,19 +686,19 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
VersionedPackage installedVersion = getInstalledPackageVersion(packageName);
synchronized (mLock) {
Iterator<RollbackData> iter = mRollbacks.iterator();
Iterator<Rollback> iter = mRollbacks.iterator();
while (iter.hasNext()) {
RollbackData data = iter.next();
Rollback rollback = iter.next();
// TODO: Should we remove rollbacks in the ENABLING state here?
if (data.state == RollbackData.ROLLBACK_STATE_AVAILABLE
|| data.state == RollbackData.ROLLBACK_STATE_ENABLING) {
for (PackageRollbackInfo info : data.info.getPackages()) {
if (rollback.state == Rollback.ROLLBACK_STATE_AVAILABLE
|| rollback.state == Rollback.ROLLBACK_STATE_ENABLING) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
if (info.getPackageName().equals(packageName)
&& !packageVersionsEqual(
info.getVersionRolledBackFrom(),
installedVersion)) {
iter.remove();
deleteRollback(data);
deleteRollback(rollback);
break;
}
}
@@ -754,17 +754,18 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
Instant now = Instant.now();
Instant oldest = null;
synchronized (mLock) {
Iterator<RollbackData> iter = mRollbacks.iterator();
Iterator<Rollback> iter = mRollbacks.iterator();
while (iter.hasNext()) {
RollbackData data = iter.next();
if (data.state != RollbackData.ROLLBACK_STATE_AVAILABLE) {
Rollback rollback = iter.next();
if (rollback.state != Rollback.ROLLBACK_STATE_AVAILABLE) {
continue;
}
if (!now.isBefore(data.timestamp.plusMillis(mRollbackLifetimeDurationInMillis))) {
if (!now.isBefore(
rollback.timestamp.plusMillis(mRollbackLifetimeDurationInMillis))) {
iter.remove();
deleteRollback(data);
} else if (oldest == null || oldest.isAfter(data.timestamp)) {
oldest = data.timestamp;
deleteRollback(rollback);
} else if (oldest == null || oldest.isAfter(rollback.timestamp)) {
oldest = rollback.timestamp;
}
}
}
@@ -871,8 +872,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// rollback enabled.
synchronized (mLock) {
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.apkSessionId == parentSession.getSessionId()) {
Rollback rollback = mRollbacks.get(i);
if (rollback.apkSessionId == parentSession.getSessionId()) {
// This is the apk session for a staged session with rollback enabled. We do not
// need to create a new rollback for this session.
return true;
@@ -893,7 +894,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
newRollback.addToken(token);
return enableRollbackForPackageSession(newRollback.data, packageSession);
return enableRollbackForPackageSession(newRollback.rollback, packageSession);
}
/**
@@ -903,7 +904,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
*
* @return true on success, false on failure.
*/
private boolean enableRollbackForPackageSession(RollbackData data,
private boolean enableRollbackForPackageSession(Rollback rollback,
PackageInstaller.SessionInfo session) {
// TODO: Don't attempt to enable rollback for split installs.
final int installFlags = session.installFlags;
@@ -966,10 +967,10 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
try {
ApplicationInfo appInfo = pkgInfo.applicationInfo;
RollbackStore.backupPackageCodePath(data, packageName, appInfo.sourceDir);
RollbackStore.backupPackageCodePath(rollback, packageName, appInfo.sourceDir);
if (!ArrayUtils.isEmpty(appInfo.splitSourceDirs)) {
for (String sourceDir : appInfo.splitSourceDirs) {
RollbackStore.backupPackageCodePath(data, packageName, sourceDir);
RollbackStore.backupPackageCodePath(rollback, packageName, sourceDir);
}
}
} catch (IOException e) {
@@ -978,7 +979,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
synchronized (mLock) {
data.info.getPackages().add(packageRollbackInfo);
rollback.info.getPackages().add(packageRollbackInfo);
}
return true;
}
@@ -1004,16 +1005,16 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
synchronized (mLock) {
// staged installs
for (int i = 0; i < mRollbacks.size(); i++) {
RollbackData data = mRollbacks.get(i);
if (data.state != RollbackData.ROLLBACK_STATE_ENABLING) {
Rollback rollback = mRollbacks.get(i);
if (rollback.state != Rollback.ROLLBACK_STATE_ENABLING) {
continue;
}
for (PackageRollbackInfo info : data.info.getPackages()) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
if (info.getPackageName().equals(packageName)) {
mAppDataRollbackHelper.snapshotAppData(
data.info.getRollbackId(), info, userIds);
saveRollbackData(data);
rollback.info.getRollbackId(), info, userIds);
saveRollback(rollback);
break;
}
}
@@ -1021,11 +1022,11 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// non-staged installs
PackageRollbackInfo info;
for (NewRollback rollback : mNewRollbacks) {
info = getPackageRollbackInfo(rollback.data, packageName);
info = getPackageRollbackInfo(rollback.rollback, packageName);
if (info != null) {
mAppDataRollbackHelper.snapshotAppData(
rollback.data.info.getRollbackId(), info, userIds);
saveRollbackData(rollback.data);
rollback.rollback.info.getRollbackId(), info, userIds);
saveRollback(rollback.rollback);
}
}
}
@@ -1034,31 +1035,31 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
private void restoreUserDataInternal(String packageName, int[] userIds, int appId,
long ceDataInode, String seInfo, int token) {
PackageRollbackInfo info = null;
RollbackData rollbackData = null;
Rollback rollback = null;
synchronized (mLock) {
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.restoreUserDataInProgress) {
info = getPackageRollbackInfo(data, packageName);
Rollback candidate = mRollbacks.get(i);
if (candidate.restoreUserDataInProgress) {
info = getPackageRollbackInfo(candidate, packageName);
if (info != null) {
rollbackData = data;
rollback = candidate;
break;
}
}
}
}
if (rollbackData == null) {
if (rollback == null) {
return;
}
for (int userId : userIds) {
final boolean changedRollbackData = mAppDataRollbackHelper.restoreAppData(
rollbackData.info.getRollbackId(), info, userId, appId, seInfo);
final boolean changedRollback = mAppDataRollbackHelper.restoreAppData(
rollback.info.getRollbackId(), info, userId, appId, seInfo);
// We've updated metadata about this rollback, so save it to flash.
if (changedRollbackData) {
saveRollbackData(rollbackData);
if (changedRollback) {
saveRollback(rollback);
}
}
}
@@ -1088,7 +1089,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
if (!session.isMultiPackage()) {
if (!enableRollbackForPackageSession(newRollback.data, session)) {
if (!enableRollbackForPackageSession(newRollback.rollback, session)) {
Slog.e(TAG, "Unable to enable rollback for session: " + sessionId);
result.offer(false);
return;
@@ -1102,7 +1103,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
result.offer(false);
return;
}
if (!enableRollbackForPackageSession(newRollback.data, childSession)) {
if (!enableRollbackForPackageSession(newRollback.rollback, childSession)) {
Slog.e(TAG, "Unable to enable rollback for session: " + sessionId);
result.offer(false);
return;
@@ -1127,20 +1128,20 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
throw new SecurityException("notifyStagedApkSession may only be called by the system.");
}
getHandler().post(() -> {
RollbackData rd = null;
Rollback rollback = null;
synchronized (mLock) {
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.stagedSessionId == originalSessionId) {
data.apkSessionId = apkSessionId;
rd = data;
Rollback candidate = mRollbacks.get(i);
if (candidate.stagedSessionId == originalSessionId) {
candidate.apkSessionId = apkSessionId;
rollback = candidate;
break;
}
}
}
if (rd != null) {
saveRollbackData(rd);
if (rollback != null) {
saveRollback(rollback);
}
});
}
@@ -1250,7 +1251,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
if (newRollback != null) {
RollbackData rollback = completeEnableRollback(newRollback, success);
Rollback rollback = completeEnableRollback(newRollback, success);
if (rollback != null && !rollback.isStaged()) {
makeRollbackAvailable(rollback);
}
@@ -1263,32 +1264,32 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
* This should be called after rollback has been enabled for all packages
* in the rollback. It does not make the rollback available yet.
*
* @return the rollback data for a successfully enable-completed rollback,
* @return the Rollback instance for a successfully enable-completed rollback,
* or null on error.
*/
private RollbackData completeEnableRollback(NewRollback newRollback, boolean success) {
RollbackData data = newRollback.data;
private Rollback completeEnableRollback(NewRollback newRollback, boolean success) {
Rollback rollback = newRollback.rollback;
if (!success) {
// The install session was aborted, clean up the pending install.
deleteRollback(data);
deleteRollback(rollback);
return null;
}
if (newRollback.isCancelled) {
Slog.e(TAG, "Rollback has been cancelled by PackageManager");
deleteRollback(data);
deleteRollback(rollback);
return null;
}
// It's safe to access data.info outside a synchronized block because
// It's safe to access rollback.info outside a synchronized block because
// this is running on the handler thread and all changes to the
// data.info occur on the handler thread.
if (data.info.getPackages().size() != newRollback.packageSessionIds.length) {
// rollback.info occur on the handler thread.
if (rollback.info.getPackages().size() != newRollback.packageSessionIds.length) {
Slog.e(TAG, "Failed to enable rollback for all packages in session.");
deleteRollback(data);
deleteRollback(rollback);
return null;
}
saveRollbackData(data);
saveRollback(rollback);
synchronized (mLock) {
// Note: There is a small window of time between when
// the session has been committed by the package
@@ -1296,25 +1297,25 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// here. Presumably the window is small enough that
// nobody will want to roll back the newly installed
// package before we make the rollback available.
// TODO: We'll lose the rollback data if the
// TODO: We'll lose the rollback if the
// device reboots between when the session is
// committed and this point. Revisit this after
// adding support for rollback of staged installs.
mRollbacks.add(data);
mRollbacks.add(rollback);
}
return data;
return rollback;
}
private void makeRollbackAvailable(RollbackData data) {
private void makeRollbackAvailable(Rollback rollback) {
// TODO: What if the rollback has since been expired, for example due
// to a new package being installed. Won't this revive an expired
// rollback? Consider adding a ROLLBACK_STATE_EXPIRED to address this.
synchronized (mLock) {
data.state = RollbackData.ROLLBACK_STATE_AVAILABLE;
data.timestamp = Instant.now();
rollback.state = Rollback.ROLLBACK_STATE_AVAILABLE;
rollback.timestamp = Instant.now();
}
saveRollbackData(data);
saveRollback(rollback);
// TODO(zezeozue): Provide API to explicitly start observing instead
// of doing this for all rollbacks. If we do this for all rollbacks,
@@ -1322,8 +1323,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
// After enabling and commiting any rollback, observe packages and
// prepare to rollback if packages crashes too frequently.
List<String> packages = new ArrayList<>();
for (int i = 0; i < data.info.getPackages().size(); i++) {
packages.add(data.info.getPackages().get(i).getPackageName());
for (int i = 0; i < rollback.info.getPackages().size(); i++) {
packages.add(rollback.info.getPackages().get(i).getPackageName());
}
mPackageHealthObserver.startObservingHealth(packages,
mRollbackLifetimeDurationInMillis);
@@ -1331,15 +1332,14 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
/*
* Returns the RollbackData, if any, for a rollback with the given
* rollbackId.
* Returns the rollback with the given rollbackId, if any.
*/
private RollbackData getRollbackForId(int rollbackId) {
private Rollback getRollbackForId(int rollbackId) {
synchronized (mLock) {
for (int i = 0; i < mRollbacks.size(); ++i) {
RollbackData data = mRollbacks.get(i);
if (data.info.getRollbackId() == rollbackId) {
return data;
Rollback rollback = mRollbacks.get(i);
if (rollback.info.getRollbackId() == rollbackId) {
return rollback;
}
}
}
@@ -1349,11 +1349,11 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
/**
* Returns the {@code PackageRollbackInfo} associated with {@code packageName} from
* a specified {@code RollbackData}.
* a specified {@code Rollback}.
*/
private static PackageRollbackInfo getPackageRollbackInfo(RollbackData data,
private static PackageRollbackInfo getPackageRollbackInfo(Rollback rollback,
String packageName) {
for (PackageRollbackInfo info : data.info.getPackages()) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
if (info.getPackageName().equals(packageName)) {
return info;
}
@@ -1377,30 +1377,30 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
throw new IllegalStateException("Failed to allocate rollback ID");
}
private void deleteRollback(RollbackData rollbackData) {
for (PackageRollbackInfo info : rollbackData.info.getPackages()) {
private void deleteRollback(Rollback rollback) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
IntArray snapshottedUsers = info.getSnapshottedUsers();
for (int i = 0; i < snapshottedUsers.size(); i++) {
int userId = snapshottedUsers.get(i);
mAppDataRollbackHelper.destroyAppDataSnapshot(rollbackData.info.getRollbackId(),
mAppDataRollbackHelper.destroyAppDataSnapshot(rollback.info.getRollbackId(),
info, userId);
}
}
mRollbackStore.deleteRollbackData(rollbackData);
mRollbackStore.deleteRollback(rollback);
}
/**
* Saves rollback data, swallowing any IOExceptions.
* Saves a rollback, swallowing any IOExceptions.
* For those times when it's not obvious what to do about the IOException.
* TODO: Double check we can't do a better job handling the IOException in
* a cases where this method is called.
*/
private void saveRollbackData(RollbackData rollbackData) {
private void saveRollback(Rollback rollback) {
try {
mRollbackStore.saveRollbackData(rollbackData);
mRollbackStore.saveRollback(rollback);
} catch (IOException ioe) {
Slog.e(TAG, "Unable to save rollback info for: "
+ rollbackData.info.getRollbackId(), ioe);
Slog.e(TAG, "Unable to save rollback for: "
+ rollback.info.getRollbackId(), ioe);
}
}
@@ -1408,14 +1408,14 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
IndentingPrintWriter ipw = new IndentingPrintWriter(pw, " ");
synchronized (mLock) {
for (RollbackData data : mRollbacks) {
RollbackInfo info = data.info;
for (Rollback rollback : mRollbacks) {
RollbackInfo info = rollback.info;
ipw.println(info.getRollbackId() + ":");
ipw.increaseIndent();
ipw.println("-state: " + data.getStateAsString());
ipw.println("-timestamp: " + data.timestamp);
if (data.stagedSessionId != -1) {
ipw.println("-stagedSessionId: " + data.stagedSessionId);
ipw.println("-state: " + rollback.getStateAsString());
ipw.println("-timestamp: " + rollback.timestamp);
if (rollback.stagedSessionId != -1) {
ipw.println("-stagedSessionId: " + rollback.stagedSessionId);
}
ipw.println("-packages:");
ipw.increaseIndent();
@@ -1425,7 +1425,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
+ " -> " + pkg.getVersionRolledBackTo().getLongVersionCode());
}
ipw.decreaseIndent();
if (data.state == RollbackData.ROLLBACK_STATE_COMMITTED) {
if (rollback.state == Rollback.ROLLBACK_STATE_COMMITTED) {
ipw.println("-causePackages:");
ipw.increaseIndent();
for (VersionedPackage cPkg : info.getCausePackages()) {
@@ -1451,7 +1451,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
}
private static class NewRollback {
public final RollbackData data;
public final Rollback rollback;
/**
* This array holds all of the rollback tokens associated with package sessions included
@@ -1469,9 +1469,9 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
public final int[] packageSessionIds;
/**
* Flag to determine whether the RollbackData has been cancelled.
* Flag to determine whether the rollback has been cancelled.
*
* <p>RollbackData could be invalidated and cancelled if RollbackManager receives
* <p>Rollback could be invalidated and cancelled if RollbackManager receives
* {@link Intent#ACTION_CANCEL_ENABLE_ROLLBACK} from {@link PackageManager}.
*
* <p>The main underlying assumption here is that if enabling the rollback times out, then
@@ -1481,8 +1481,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
*/
public boolean isCancelled = false;
NewRollback(RollbackData data, int[] packageSessionIds) {
this.data = data;
NewRollback(Rollback rollback, int[] packageSessionIds) {
this.rollback = rollback;
this.packageSessionIds = packageSessionIds;
}
@@ -1497,13 +1497,13 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
NewRollback createNewRollbackLocked(PackageInstaller.SessionInfo parentSession) {
int rollbackId = allocateRollbackIdLocked();
final RollbackData data;
final Rollback rollback;
int parentSessionId = parentSession.getSessionId();
if (parentSession.isStaged()) {
data = mRollbackStore.createStagedRollback(rollbackId, parentSessionId);
rollback = mRollbackStore.createStagedRollback(rollbackId, parentSessionId);
} else {
data = mRollbackStore.createNonStagedRollback(rollbackId);
rollback = mRollbackStore.createNonStagedRollback(rollbackId);
}
int[] packageSessionIds;
@@ -1513,7 +1513,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
packageSessionIds = new int[]{parentSessionId};
}
return new NewRollback(data, packageSessionIds);
return new NewRollback(rollback, packageSessionIds);
}
/**
@@ -1524,10 +1524,10 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub {
NewRollback getNewRollbackForPackageSessionLocked(int packageSessionId) {
// We expect mNewRollbacks to be a very small list; linear search
// should be plenty fast.
for (NewRollback newRollbackData : mNewRollbacks) {
for (int id : newRollbackData.packageSessionIds) {
for (NewRollback newRollback: mNewRollbacks) {
for (int id : newRollback.packageSessionIds) {
if (id == packageSessionId) {
return newRollbackData;
return newRollback;
}
}
}

68
services/core/java/com/android/server/rollback/RollbackStore.java
View File

@@ -16,8 +16,8 @@
package com.android.server.rollback;
import static com.android.server.rollback.RollbackData.rollbackStateFromString;
import static com.android.server.rollback.RollbackData.rollbackStateToString;
import static com.android.server.rollback.Rollback.rollbackStateFromString;
import static com.android.server.rollback.Rollback.rollbackStateToString;
import android.annotation.NonNull;
import android.content.pm.VersionedPackage;
@@ -73,17 +73,17 @@ class RollbackStore {
}
/**
* Reads the rollback data from persistent storage.
* Reads the rollbacks from persistent storage.
*/
List<RollbackData> loadAllRollbackData() {
List<RollbackData> rollbacks = new ArrayList<>();
List<Rollback> loadRollbacks() {
List<Rollback> rollbacks = new ArrayList<>();
mRollbackDataDir.mkdirs();
for (File rollbackDir : mRollbackDataDir.listFiles()) {
if (rollbackDir.isDirectory()) {
try {
rollbacks.add(loadRollbackData(rollbackDir));
rollbacks.add(loadRollback(rollbackDir));
} catch (IOException e) {
Slog.e(TAG, "Unable to read rollback data at " + rollbackDir, e);
Slog.e(TAG, "Unable to read rollback at " + rollbackDir, e);
removeFile(rollbackDir);
}
}
@@ -191,21 +191,21 @@ class RollbackStore {
}
/**
* Creates a new RollbackData instance for a non-staged rollback with
* Creates a new Rollback instance for a non-staged rollback with
* backupDir assigned.
*/
RollbackData createNonStagedRollback(int rollbackId) {
Rollback createNonStagedRollback(int rollbackId) {
File backupDir = new File(mRollbackDataDir, Integer.toString(rollbackId));
return new RollbackData(rollbackId, backupDir, -1);
return new Rollback(rollbackId, backupDir, -1);
}
/**
* Creates a new RollbackData instance for a staged rollback with
* Creates a new Rollback instance for a staged rollback with
* backupDir assigned.
*/
RollbackData createStagedRollback(int rollbackId, int stagedSessionId) {
Rollback createStagedRollback(int rollbackId, int stagedSessionId) {
File backupDir = new File(mRollbackDataDir, Integer.toString(rollbackId));
return new RollbackData(rollbackId, backupDir, stagedSessionId);
return new Rollback(rollbackId, backupDir, stagedSessionId);
}
/**
@@ -213,10 +213,10 @@ class RollbackStore {
* For packages containing splits, this method should be called for each
* of the package's split apks in addition to the base apk.
*/
static void backupPackageCodePath(RollbackData data, String packageName, String codePath)
static void backupPackageCodePath(Rollback rollback, String packageName, String codePath)
throws IOException {
File sourceFile = new File(codePath);
File targetDir = new File(data.backupDir, packageName);
File targetDir = new File(rollback.backupDir, packageName);
targetDir.mkdirs();
File targetFile = new File(targetDir, sourceFile.getName());
@@ -228,8 +228,8 @@ class RollbackStore {
* Returns the apk or apex files backed up for the given package.
* Includes the base apk and any splits. Returns null if none found.
*/
static File[] getPackageCodePaths(RollbackData data, String packageName) {
File targetDir = new File(data.backupDir, packageName);
static File[] getPackageCodePaths(Rollback rollback, String packageName) {
File targetDir = new File(rollback.backupDir, packageName);
File[] files = targetDir.listFiles();
if (files == null || files.length == 0) {
return null;
@@ -241,27 +241,27 @@ class RollbackStore {
* Deletes all backed up apks and apex files associated with the given
* rollback.
*/
static void deletePackageCodePaths(RollbackData data) {
for (PackageRollbackInfo info : data.info.getPackages()) {
File targetDir = new File(data.backupDir, info.getPackageName());
static void deletePackageCodePaths(Rollback rollback) {
for (PackageRollbackInfo info : rollback.info.getPackages()) {
File targetDir = new File(rollback.backupDir, info.getPackageName());
removeFile(targetDir);
}
}
/**
* Saves the rollback data to persistent storage.
* Saves the given rollback to persistent storage.
*/
void saveRollbackData(RollbackData data) throws IOException {
void saveRollback(Rollback rollback) throws IOException {
try {
JSONObject dataJson = new JSONObject();
dataJson.put("info", rollbackInfoToJson(data.info));
dataJson.put("timestamp", data.timestamp.toString());
dataJson.put("stagedSessionId", data.stagedSessionId);
dataJson.put("state", rollbackStateToString(data.state));
dataJson.put("apkSessionId", data.apkSessionId);
dataJson.put("restoreUserDataInProgress", data.restoreUserDataInProgress);
dataJson.put("info", rollbackInfoToJson(rollback.info));
dataJson.put("timestamp", rollback.timestamp.toString());
dataJson.put("stagedSessionId", rollback.stagedSessionId);
dataJson.put("state", rollbackStateToString(rollback.state));
dataJson.put("apkSessionId", rollback.apkSessionId);
dataJson.put("restoreUserDataInProgress", rollback.restoreUserDataInProgress);
PrintWriter pw = new PrintWriter(new File(data.backupDir, "rollback.json"));
PrintWriter pw = new PrintWriter(new File(rollback.backupDir, "rollback.json"));
pw.println(dataJson.toString());
pw.close();
} catch (JSONException e) {
@@ -270,23 +270,23 @@ class RollbackStore {
}
/**
* Removes all persistant storage associated with the given rollback data.
* Removes all persistent storage associated with the given rollback.
*/
void deleteRollbackData(RollbackData data) {
removeFile(data.backupDir);
void deleteRollback(Rollback rollback) {
removeFile(rollback.backupDir);
}
/**
* Reads the metadata for a rollback from the given directory.
* @throws IOException in case of error reading the data.
*/
private static RollbackData loadRollbackData(File backupDir) throws IOException {
private static Rollback loadRollback(File backupDir) throws IOException {
try {
File rollbackJsonFile = new File(backupDir, "rollback.json");
JSONObject dataJson = new JSONObject(
IoUtils.readFileAsString(rollbackJsonFile.getAbsolutePath()));
return new RollbackData(
return new Rollback(
rollbackInfoFromJson(dataJson.getJSONObject("info")),
backupDir,
Instant.parse(dataJson.getString("timestamp")),

12
services/tests/servicestests/src/com/android/server/rollback/AppDataRollbackHelperTest.java
View File

@@ -235,22 +235,22 @@ public class AppDataRollbackHelperTest {
wasRecentlyRestored.getPendingRestores().add(
new RestoreInfo(73 /* userId */, 239 /* appId*/, "seInfo"));
RollbackData dataWithPendingBackup = new RollbackData(101, new File("/does/not/exist"), -1);
Rollback dataWithPendingBackup = new Rollback(101, new File("/does/not/exist"), -1);
dataWithPendingBackup.info.getPackages().add(pendingBackup);
RollbackData dataWithRecentRestore = new RollbackData(17239, new File("/does/not/exist"),
Rollback dataWithRecentRestore = new Rollback(17239, new File("/does/not/exist"),
-1);
dataWithRecentRestore.info.getPackages().add(wasRecentlyRestored);
RollbackData dataForDifferentUser = new RollbackData(17239, new File("/does/not/exist"),
Rollback dataForDifferentUser = new Rollback(17239, new File("/does/not/exist"),
-1);
dataForDifferentUser.info.getPackages().add(ignoredInfo);
RollbackData dataForRestore = new RollbackData(17239, new File("/does/not/exist"), -1);
Rollback dataForRestore = new Rollback(17239, new File("/does/not/exist"), -1);
dataForRestore.info.getPackages().add(pendingRestore);
dataForRestore.info.getPackages().add(wasRecentlyRestored);
Set<RollbackData> changed = helper.commitPendingBackupAndRestoreForUser(37,
Set<Rollback> changed = helper.commitPendingBackupAndRestoreForUser(37,
Arrays.asList(dataWithPendingBackup, dataWithRecentRestore, dataForDifferentUser,
dataForRestore));
InOrder inOrder = Mockito.inOrder(installer);
@@ -265,7 +265,7 @@ public class AppDataRollbackHelperTest {
assertEquals(-1, pendingBackup.getPendingBackups().indexOf(37));
assertEquals(53, pendingBackup.getCeSnapshotInodes().get(37));
// Check that changed returns correct RollbackData.
// Check that changed returns correct Rollback.
assertEquals(3, changed.size());
assertTrue(changed.contains(dataWithPendingBackup));
assertTrue(changed.contains(dataWithRecentRestore));