Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 08a4c7f7 authored by Yurii Zubrytskyi's avatar Yurii Zubrytskyi
Browse files

[incfs] Small cleanup in staging -> final dir rename 

Bug: 153704006
Test: atest PackageManagerShellCommandTest \
  PackageManagerShellCommandIncrementalTest \
  IncrementalServiceTest
Change-Id: I227d8e0cba6554bf8cf58a16598f34ccbf3d21c0
parent 629051fd

core/java/android/os/incremental/IncrementalManager.java

+40 −52
Original line number Diff line number Diff line
@@ -32,8 +32,12 @@ import java.io.File; 
import java.io.IOException;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;



/**

 * Provides operations to open or create an IncrementalStorage, using IIncrementalService
@@ -175,25 +179,6 @@ public final class IncrementalManager { 
        }

    }



    /**

     * Iterates through path parents to find the base dir of an Incremental Storage.

     *

     * @param file Target file to search storage for.

     * @return Absolute path which is a bind-mount point of Incremental File System.

     */

    @Nullable

    private Path getStoragePathForFile(File file) {

        File currentPath = new File(file.getParent());

        while (currentPath.getParent() != null) {

            IncrementalStorage storage = openStorage(currentPath.getAbsolutePath());

            if (storage != null) {

                return currentPath.toPath();

            }

            currentPath = new File(currentPath.getParent());

        }

        return null;

    }



    /**

     * Set up an app's code path. The expected outcome of this method is:

     * 1) The actual apk directory under /data/incremental is bind-mounted to the parent directory
@@ -212,29 +197,27 @@ public final class IncrementalManager { 
     */

    public void renameCodePath(File beforeCodeFile, File afterCodeFile)

            throws IllegalArgumentException, IOException {

        final String beforeCodePath = beforeCodeFile.getAbsolutePath();

        final String afterCodePathParent = afterCodeFile.getParentFile().getAbsolutePath();

        if (!isIncrementalPath(beforeCodePath)) {

            throw new IllegalArgumentException("Not an Incremental path: " + beforeCodePath);

        }

        final String afterCodePathName = afterCodeFile.getName();

        final Path apkStoragePath = Paths.get(beforeCodePath);

        if (apkStoragePath == null || apkStoragePath.toAbsolutePath() == null) {

            throw new IOException("Invalid source storage path for: " + beforeCodePath);

        }

        final IncrementalStorage apkStorage =

                openStorage(apkStoragePath.toAbsolutePath().toString());

        final File beforeCodeAbsolute = beforeCodeFile.getAbsoluteFile();

        final IncrementalStorage apkStorage = openStorage(beforeCodeAbsolute.toString());

        if (apkStorage == null) {

            throw new IOException("Failed to retrieve storage from Incremental Service.");

            throw new IllegalArgumentException("Not an Incremental path: " + beforeCodeAbsolute);

        }

        final IncrementalStorage linkedApkStorage = createStorage(afterCodePathParent, apkStorage,

        final String targetStorageDir = afterCodeFile.getAbsoluteFile().getParent();

        final IncrementalStorage linkedApkStorage =

                createStorage(targetStorageDir, apkStorage,

                        IncrementalManager.CREATE_MODE_CREATE

                                | IncrementalManager.CREATE_MODE_PERMANENT_BIND);

        if (linkedApkStorage == null) {

            throw new IOException("Failed to create linked storage at dir: " + afterCodePathParent);

            throw new IOException("Failed to create linked storage at dir: " + targetStorageDir);

        }

        try {

            final String afterCodePathName = afterCodeFile.getName();

            linkFiles(apkStorage, beforeCodeAbsolute, "", linkedApkStorage, afterCodePathName);

            apkStorage.unBind(beforeCodeAbsolute.toString());

        } catch (Exception e) {

            linkedApkStorage.unBind(targetStorageDir);

            throw e;

        }

        linkFiles(apkStorage, beforeCodeFile, "", linkedApkStorage, afterCodePathName);

        apkStorage.unBind(beforeCodePath);

    }



    /**
@@ -252,22 +235,27 @@ public final class IncrementalManager { 
    private void linkFiles(IncrementalStorage sourceStorage, File sourceAbsolutePath,

            String sourceRelativePath, IncrementalStorage targetStorage,

            String targetRelativePath) throws IOException {

        targetStorage.makeDirectory(targetRelativePath);

        final File[] entryList = sourceAbsolutePath.listFiles();

        for (int i = 0; i < entryList.length; i++) {

            final File entry = entryList[i];

            final String entryName = entryList[i].getName();

            final String sourceEntryRelativePath =

                    sourceRelativePath.isEmpty() ? entryName : sourceRelativePath + "/" + entryName;

            final String targetEntryRelativePath = targetRelativePath + "/" + entryName;

            if (entry.isFile()) {

                sourceStorage.makeLink(

                        sourceEntryRelativePath, targetStorage, targetEntryRelativePath);

            } else if (entry.isDirectory()) {

                linkFiles(sourceStorage, entry, sourceEntryRelativePath, targetStorage,

                        targetEntryRelativePath);

        final Path sourceBase = sourceAbsolutePath.toPath().resolve(sourceRelativePath);

        final Path targetRelative = Paths.get(targetRelativePath);

        Files.walkFileTree(sourceAbsolutePath.toPath(), new SimpleFileVisitor<Path>() {

            @Override

            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)

                    throws IOException {

                final Path relativeDir = sourceBase.relativize(dir);

                targetStorage.makeDirectory(targetRelative.resolve(relativeDir).toString());

                return FileVisitResult.CONTINUE;

            }



            @Override

            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)

                    throws IOException {

                final Path relativeFile = sourceBase.relativize(file);

                sourceStorage.makeLink(

                        file.toAbsolutePath().toString(), targetStorage,

                        targetRelative.resolve(relativeFile).toString());

                return FileVisitResult.CONTINUE;

            }

        });

    }



    /**