directly call data loader manager service from incremental service
BUG: 150406132
Test: atest service.incremental_test
Test: atest PackageManagerShellCommandIncrementalTest
Change-Id: I2bb75d5adae58d2471478f6a4d2354058d7b0dab
diff --git a/services/incremental/IncrementalService.cpp b/services/incremental/IncrementalService.cpp
index 980ae08..2426e8f 100644
--- a/services/incremental/IncrementalService.cpp
+++ b/services/incremental/IncrementalService.cpp
@@ -155,7 +155,7 @@
} // namespace
IncrementalService::IncFsMount::~IncFsMount() {
- incrementalService.mIncrementalManager->destroyDataLoader(mountId);
+ incrementalService.mDataLoaderManager->destroyDataLoader(mountId);
control.reset();
LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';
for (auto&& [target, _] : bindPoints) {
@@ -229,14 +229,14 @@
IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)
: mVold(sm.getVoldService()),
- mIncrementalManager(sm.getIncrementalManager()),
+ mDataLoaderManager(sm.getDataLoaderManager()),
mIncFs(sm.getIncFs()),
mIncrementalDir(rootDir) {
if (!mVold) {
LOG(FATAL) << "Vold service is unavailable";
}
- if (!mIncrementalManager) {
- LOG(FATAL) << "IncrementalManager service is unavailable";
+ if (!mDataLoaderManager) {
+ LOG(FATAL) << "DataLoaderManagerService is unavailable";
}
mountExistingImages();
}
@@ -921,7 +921,6 @@
if (!ifs) {
return false;
}
- bool started = false;
std::unique_lock l(ifs->lock);
if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {
if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {
@@ -929,11 +928,19 @@
return false;
}
}
- auto status = mIncrementalManager->startDataLoader(ifs->mountId, &started);
+ sp<IDataLoader> dataloader;
+ auto status = mDataLoaderManager->getDataLoader(ifs->mountId, &dataloader);
if (!status.isOk()) {
return false;
}
- return started;
+ if (!dataloader) {
+ return false;
+ }
+ status = dataloader->start();
+ if (!status.isOk()) {
+ return false;
+ }
+ return true;
}
void IncrementalService::mountExistingImages() {
@@ -1086,8 +1093,8 @@
sp<IncrementalDataLoaderListener> listener =
new IncrementalDataLoaderListener(*this, *externalListener);
bool created = false;
- auto status = mIncrementalManager->prepareDataLoader(ifs.mountId, fsControlParcel, *dlp,
- listener, &created);
+ auto status = mDataLoaderManager->initializeDataLoader(ifs.mountId, *dlp, fsControlParcel,
+ listener, &created);
if (!status.isOk() || !created) {
LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;
return false;
@@ -1229,16 +1236,7 @@
ifs->dataLoaderStatus = newStatus;
switch (newStatus) {
case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {
- auto now = Clock::now();
- if (ifs->connectionLostTime.time_since_epoch().count() == 0) {
- ifs->connectionLostTime = now;
- break;
- }
- auto duration =
- std::chrono::duration_cast<Seconds>(now - ifs->connectionLostTime).count();
- if (duration >= 10) {
- incrementalService.mIncrementalManager->showHealthBlockedUI(mountId);
- }
+ // TODO(b/150411019): handle data loader connection loss
break;
}
case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {
diff --git a/services/incremental/IncrementalService.h b/services/incremental/IncrementalService.h
index 19424973..8ff441b 100644
--- a/services/incremental/IncrementalService.h
+++ b/services/incremental/IncrementalService.h
@@ -19,7 +19,6 @@
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include <android/content/pm/DataLoaderParamsParcel.h>
-#include <android/os/incremental/IIncrementalManager.h>
#include <binder/IServiceManager.h>
#include <utils/String16.h>
#include <utils/StrongPointer.h>
@@ -220,7 +219,7 @@
// Member variables
std::unique_ptr<VoldServiceWrapper> mVold;
- std::unique_ptr<IncrementalManagerWrapper> mIncrementalManager;
+ std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;
std::unique_ptr<IncFsWrapper> mIncFs;
const std::string mIncrementalDir;
diff --git a/services/incremental/ServiceWrappers.cpp b/services/incremental/ServiceWrappers.cpp
index 5d978a1c..2e31ef1 100644
--- a/services/incremental/ServiceWrappers.cpp
+++ b/services/incremental/ServiceWrappers.cpp
@@ -23,7 +23,7 @@
namespace android::os::incremental {
static constexpr auto kVoldServiceName = "vold"sv;
-static constexpr auto kIncrementalManagerName = "incremental"sv;
+static constexpr auto kDataLoaderManagerName = "dataloader_manager"sv;
RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)
: mServiceManager(std::move(serviceManager)) {}
@@ -46,11 +46,11 @@
return nullptr;
}
-std::unique_ptr<IncrementalManagerWrapper> RealServiceManager::getIncrementalManager() {
- sp<IIncrementalManager> manager =
- RealServiceManager::getRealService<IIncrementalManager>(kIncrementalManagerName);
+std::unique_ptr<DataLoaderManagerWrapper> RealServiceManager::getDataLoaderManager() {
+ sp<IDataLoaderManager> manager =
+ RealServiceManager::getRealService<IDataLoaderManager>(kDataLoaderManagerName);
if (manager) {
- return std::make_unique<RealIncrementalManager>(manager);
+ return std::make_unique<RealDataLoaderManager>(manager);
}
return nullptr;
}
diff --git a/services/incremental/ServiceWrappers.h b/services/incremental/ServiceWrappers.h
index c574ca7..5349ebf 100644
--- a/services/incremental/ServiceWrappers.h
+++ b/services/incremental/ServiceWrappers.h
@@ -20,9 +20,10 @@
#include <android-base/unique_fd.h>
#include <android/content/pm/DataLoaderParamsParcel.h>
#include <android/content/pm/FileSystemControlParcel.h>
+#include <android/content/pm/IDataLoader.h>
+#include <android/content/pm/IDataLoaderManager.h>
#include <android/content/pm/IDataLoaderStatusListener.h>
#include <android/os/IVold.h>
-#include <android/os/incremental/IIncrementalManager.h>
#include <binder/IServiceManager.h>
#include <incfs.h>
@@ -50,17 +51,16 @@
const std::string& targetDir) const = 0;
};
-class IncrementalManagerWrapper {
+class DataLoaderManagerWrapper {
public:
- virtual ~IncrementalManagerWrapper() = default;
- virtual binder::Status prepareDataLoader(MountId mountId,
- const FileSystemControlParcel& control,
- const DataLoaderParamsParcel& params,
- const sp<IDataLoaderStatusListener>& listener,
- bool* _aidl_return) const = 0;
- virtual binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const = 0;
+ virtual ~DataLoaderManagerWrapper() = default;
+ virtual binder::Status initializeDataLoader(MountId mountId,
+ const DataLoaderParamsParcel& params,
+ const FileSystemControlParcel& control,
+ const sp<IDataLoaderStatusListener>& listener,
+ bool* _aidl_return) const = 0;
+ virtual binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const = 0;
virtual binder::Status destroyDataLoader(MountId mountId) const = 0;
- virtual binder::Status showHealthBlockedUI(MountId mountId) const = 0;
};
class IncFsWrapper {
@@ -82,7 +82,7 @@
public:
virtual ~ServiceManagerWrapper() = default;
virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;
- virtual std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() = 0;
+ virtual std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() = 0;
virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;
};
@@ -109,29 +109,26 @@
sp<os::IVold> mInterface;
};
-class RealIncrementalManager : public IncrementalManagerWrapper {
+class RealDataLoaderManager : public DataLoaderManagerWrapper {
public:
- RealIncrementalManager(const sp<os::incremental::IIncrementalManager> manager)
+ RealDataLoaderManager(const sp<content::pm::IDataLoaderManager> manager)
: mInterface(manager) {}
- ~RealIncrementalManager() = default;
- binder::Status prepareDataLoader(MountId mountId, const FileSystemControlParcel& control,
- const DataLoaderParamsParcel& params,
- const sp<IDataLoaderStatusListener>& listener,
- bool* _aidl_return) const override {
- return mInterface->prepareDataLoader(mountId, control, params, listener, _aidl_return);
+ ~RealDataLoaderManager() = default;
+ binder::Status initializeDataLoader(MountId mountId, const DataLoaderParamsParcel& params,
+ const FileSystemControlParcel& control,
+ const sp<IDataLoaderStatusListener>& listener,
+ bool* _aidl_return) const override {
+ return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);
}
- binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const override {
- return mInterface->startDataLoader(mountId, _aidl_return);
+ binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const override {
+ return mInterface->getDataLoader(mountId, _aidl_return);
}
binder::Status destroyDataLoader(MountId mountId) const override {
return mInterface->destroyDataLoader(mountId);
}
- binder::Status showHealthBlockedUI(MountId mountId) const override {
- return mInterface->showHealthBlockedUI(mountId);
- }
private:
- sp<os::incremental::IIncrementalManager> mInterface;
+ sp<content::pm::IDataLoaderManager> mInterface;
};
class RealServiceManager : public ServiceManagerWrapper {
@@ -139,7 +136,7 @@
RealServiceManager(sp<IServiceManager> serviceManager);
~RealServiceManager() = default;
std::unique_ptr<VoldServiceWrapper> getVoldService() override;
- std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() override;
+ std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() override;
std::unique_ptr<IncFsWrapper> getIncFs() override;
private:
diff --git a/services/incremental/test/IncrementalServiceTest.cpp b/services/incremental/test/IncrementalServiceTest.cpp
index aca6ca4..6002226 100644
--- a/services/incremental/test/IncrementalServiceTest.cpp
+++ b/services/incremental/test/IncrementalServiceTest.cpp
@@ -93,47 +93,60 @@
TemporaryFile logFile;
};
-class MockIncrementalManager : public IncrementalManagerWrapper {
+class FakeDataLoader : public IDataLoader {
public:
- MOCK_CONST_METHOD5(prepareDataLoader,
- binder::Status(int32_t mountId, const FileSystemControlParcel& control,
- const DataLoaderParamsParcel& params,
+ IBinder* onAsBinder() override { return nullptr; }
+ binder::Status create(int32_t, const DataLoaderParamsParcel&, const FileSystemControlParcel&,
+ const sp<IDataLoaderStatusListener>&) override {
+ return binder::Status::ok();
+ }
+ binder::Status start() override { return binder::Status::ok(); }
+ binder::Status stop() override { return binder::Status::ok(); }
+ binder::Status destroy() override { return binder::Status::ok(); }
+ binder::Status prepareImage(const std::vector<InstallationFileParcel>&,
+ const std::vector<std::string>&) override {
+ return binder::Status::ok();
+ }
+};
+
+class MockDataLoaderManager : public DataLoaderManagerWrapper {
+public:
+ MOCK_CONST_METHOD5(initializeDataLoader,
+ binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,
+ const FileSystemControlParcel& control,
const sp<IDataLoaderStatusListener>& listener,
bool* _aidl_return));
- MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));
+ MOCK_CONST_METHOD2(getDataLoader,
+ binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));
MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));
- MOCK_CONST_METHOD3(newFileForDataLoader,
- binder::Status(int32_t mountId, FileId fileId,
- const ::std::vector<uint8_t>& metadata));
- MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));
- binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,
- const DataLoaderParamsParcel& params,
- const sp<IDataLoaderStatusListener>& listener,
- bool* _aidl_return) {
+ binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,
+ const FileSystemControlParcel& control,
+ const sp<IDataLoaderStatusListener>& listener,
+ bool* _aidl_return) {
mId = mountId;
mListener = listener;
*_aidl_return = true;
return binder::Status::ok();
}
- binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {
- *_aidl_return = true;
+ binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {
+ *_aidl_return = mDataLoader;
return binder::Status::ok();
}
- void prepareDataLoaderFails() {
- ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
+ void initializeDataLoaderFails() {
+ ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
.WillByDefault(Return(
(binder::Status::fromExceptionCode(1, String8("failed to prepare")))));
}
- void prepareDataLoaderSuccess() {
- ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
- .WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));
+ void initializeDataLoaderSuccess() {
+ ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
+ .WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));
}
- void startDataLoaderSuccess() {
- ON_CALL(*this, startDataLoader(_, _))
- .WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));
+ void getDataLoaderSuccess() {
+ ON_CALL(*this, getDataLoader(_, _))
+ .WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));
}
void setDataLoaderStatusNotReady() {
mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
@@ -145,6 +158,7 @@
private:
int mId;
sp<IDataLoaderStatusListener> mListener;
+ sp<IDataLoader> mDataLoader = sp<IDataLoader>(new FakeDataLoader());
};
class MockIncFs : public IncFsWrapper {
@@ -197,20 +211,20 @@
class MockServiceManager : public ServiceManagerWrapper {
public:
MockServiceManager(std::unique_ptr<MockVoldService> vold,
- std::unique_ptr<MockIncrementalManager> manager,
+ std::unique_ptr<MockDataLoaderManager> manager,
std::unique_ptr<MockIncFs> incfs)
: mVold(std::move(vold)),
- mIncrementalManager(std::move(manager)),
+ mDataLoaderManager(std::move(manager)),
mIncFs(std::move(incfs)) {}
std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }
- std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {
- return std::move(mIncrementalManager);
+ std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() final {
+ return std::move(mDataLoaderManager);
}
std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }
private:
std::unique_ptr<MockVoldService> mVold;
- std::unique_ptr<MockIncrementalManager> mIncrementalManager;
+ std::unique_ptr<MockDataLoaderManager> mDataLoaderManager;
std::unique_ptr<MockIncFs> mIncFs;
};
@@ -221,14 +235,14 @@
void SetUp() override {
auto vold = std::make_unique<NiceMock<MockVoldService>>();
mVold = vold.get();
- auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();
- mIncrementalManager = incrementalManager.get();
+ auto dataloaderManager = std::make_unique<NiceMock<MockDataLoaderManager>>();
+ mDataLoaderManager = dataloaderManager.get();
auto incFs = std::make_unique<NiceMock<MockIncFs>>();
mIncFs = incFs.get();
mIncrementalService =
std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),
std::move(
- incrementalManager),
+ dataloaderManager),
std::move(incFs)),
mRootDir.path);
mDataLoaderParcel.packageName = "com.test";
@@ -260,7 +274,7 @@
protected:
NiceMock<MockVoldService>* mVold;
NiceMock<MockIncFs>* mIncFs;
- NiceMock<MockIncrementalManager>* mIncrementalManager;
+ NiceMock<MockDataLoaderManager>* mDataLoaderManager;
std::unique_ptr<IncrementalService> mIncrementalService;
TemporaryDir mRootDir;
DataLoaderParamsParcel mDataLoaderParcel;
@@ -268,7 +282,7 @@
TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
mVold->mountIncFsFails();
- EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -278,7 +292,7 @@
TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {
mVold->mountIncFsInvalidControlParcel();
- EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -289,8 +303,8 @@
TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {
mVold->mountIncFsSuccess();
mIncFs->makeFileFails();
- EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_));
TemporaryDir tempDir;
int storageId =
@@ -303,8 +317,8 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountFails();
- EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_));
TemporaryDir tempDir;
int storageId =
@@ -317,8 +331,8 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderFails();
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ mDataLoaderManager->initializeDataLoaderFails();
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
TemporaryDir tempDir;
int storageId =
@@ -331,8 +345,8 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderSuccess();
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ mDataLoaderManager->initializeDataLoaderSuccess();
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
TemporaryDir tempDir;
int storageId =
@@ -346,31 +360,31 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderSuccess();
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ mDataLoaderManager->initializeDataLoaderSuccess();
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
- mIncrementalManager->setDataLoaderStatusNotReady();
+ mDataLoaderManager->setDataLoaderStatusNotReady();
}
TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderSuccess();
- mIncrementalManager->startDataLoaderSuccess();
- EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+ mDataLoaderManager->initializeDataLoaderSuccess();
+ mDataLoaderManager->getDataLoaderSuccess();
+ EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
- mIncrementalManager->setDataLoaderStatusReady();
+ mDataLoaderManager->setDataLoaderStatusReady();
ASSERT_TRUE(mIncrementalService->startLoading(storageId));
}
@@ -378,8 +392,8 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderSuccess();
- mIncrementalManager->startDataLoaderSuccess();
+ mDataLoaderManager->initializeDataLoaderSuccess();
+ mDataLoaderManager->getDataLoaderSuccess();
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -402,8 +416,8 @@
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
- mIncrementalManager->prepareDataLoaderSuccess();
- mIncrementalManager->startDataLoaderSuccess();
+ mDataLoaderManager->initializeDataLoaderSuccess();
+ mDataLoaderManager->getDataLoaderSuccess();
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},