PawletOS/android_bootable_recovery
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "nonab_on_vab_r" into rvc-dev

Browse Source 
* changes:
  Add add_slot_suffix function.
  Add slot suffix to DAP ops
  Detect non-A/B vs. A/B packages correctly.
This commit is contained in:
TreeHugger Robot
2020-05-13 17:26:44 +00:00
committed by Android (Google) Code Review
parent 94abf26ba2 dff8004275
commit b62ff1abe3
9 changed files with 121 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.clang-format
+1
View File
@@ -36,6 +36,7 @@ AllowShortIfStatementsOnASingleLine: true
ColumnLimit: 100 ColumnLimit: 100
CommentPragmas: NOLINT:.* CommentPragmas: NOLINT:.*
DerivePointerAlignment: false DerivePointerAlignment: false
IncludeBlocks: Preserve
IndentWidth: 2 IndentWidth: 2
PointerAlignment: Left PointerAlignment: Left
TabWidth: 2 TabWidth: 2
edify/include/edify/updater_runtime_interface.h
+3
View File
@@ -71,4 +71,7 @@ class UpdaterRuntimeInterface {
virtual bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) = 0; virtual bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) = 0;
virtual bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) = 0; virtual bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) = 0;
virtual bool UpdateDynamicPartitions(const std::string_view op_list_value) = 0; virtual bool UpdateDynamicPartitions(const std::string_view op_list_value) = 0;
// On devices supports A/B, add current slot suffix to arg. Otherwise, return |arg| as is.
virtual std::string AddSlotSuffix(const std::string_view arg) const = 0;
}; };
install/install.cpp
+19 -8
View File
@@ -331,15 +331,25 @@ static InstallResult TryUpdateBinary(Package* package, bool* wipe_cache,
return INSTALL_CORRUPT; return INSTALL_CORRUPT;
} }
bool is_ab = android::base::GetBoolProperty("ro.build.ab_update", false); bool package_is_ab = get_value(metadata, "ota-type") == OtaTypeToString(OtaType::AB);
if (is_ab) { bool device_supports_ab = android::base::GetBoolProperty("ro.build.ab_update", false);
bool ab_device_supports_nonab =
android::base::GetBoolProperty("ro.virtual_ab.allow_non_ab", false);
bool device_only_supports_ab = device_supports_ab && !ab_device_supports_nonab;
if (package_is_ab) {
CHECK(package->GetType() == PackageType::kFile); CHECK(package->GetType() == PackageType::kFile);
} }
// Verify against the metadata in the package first. // Verify against the metadata in the package first. Expects A/B metadata if:
if (is_ab && !CheckPackageMetadata(metadata, OtaType::AB)) { // Package declares itself as an A/B package
log_buffer->push_back(android::base::StringPrintf("error: %d", kUpdateBinaryCommandFailure)); // Package does not declare itself as an A/B package, but device only supports A/B;
return INSTALL_ERROR; // still calls CheckPackageMetadata to get a meaningful error message.
if (package_is_ab || device_only_supports_ab) {
if (!CheckPackageMetadata(metadata, OtaType::AB)) {
log_buffer->push_back(android::base::StringPrintf("error: %d", kUpdateBinaryCommandFailure));
return INSTALL_ERROR;
}
} }
ReadSourceTargetBuild(metadata, log_buffer); ReadSourceTargetBuild(metadata, log_buffer);
@@ -389,8 +399,9 @@ static InstallResult TryUpdateBinary(Package* package, bool* wipe_cache,
std::vector<std::string> args; std::vector<std::string> args;
if (auto setup_result = if (auto setup_result =
is_ab ? SetUpAbUpdateCommands(package_path, zip, pipe_write.get(), &args) package_is_ab
: SetUpNonAbUpdateCommands(package_path, zip, retry_count, pipe_write.get(), &args); ? SetUpAbUpdateCommands(package_path, zip, pipe_write.get(), &args)
: SetUpNonAbUpdateCommands(package_path, zip, retry_count, pipe_write.get(), &args);
!setup_result) { !setup_result) {
log_buffer->push_back(android::base::StringPrintf("error: %d", kUpdateBinaryCommandFailure)); log_buffer->push_back(android::base::StringPrintf("error: %d", kUpdateBinaryCommandFailure));
return INSTALL_CORRUPT; return INSTALL_CORRUPT;
updater/include/updater/simulator_runtime.h
+1
View File
@@ -53,6 +53,7 @@ class SimulatorRuntime : public UpdaterRuntimeInterface {
bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) override; bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) override;
bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) override; bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) override;
bool UpdateDynamicPartitions(const std::string_view op_list_value) override; bool UpdateDynamicPartitions(const std::string_view op_list_value) override;
std::string AddSlotSuffix(const std::string_view arg) const override;
private: private:
std::string FindBlockDeviceName(const std::string_view name) const override; std::string FindBlockDeviceName(const std::string_view name) const override;
updater/include/updater/updater_runtime.h
+1
View File
@@ -56,6 +56,7 @@ class UpdaterRuntime : public UpdaterRuntimeInterface {
bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) override; bool MapPartitionOnDeviceMapper(const std::string& partition_name, std::string* path) override;
bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) override; bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) override;
bool UpdateDynamicPartitions(const std::string_view op_list_value) override; bool UpdateDynamicPartitions(const std::string_view op_list_value) override;
std::string AddSlotSuffix(const std::string_view arg) const override;
private: private:
struct selabel_handle* sehandle_{ nullptr }; struct selabel_handle* sehandle_{ nullptr };
updater/install.cpp
+16
View File
@@ -852,6 +852,20 @@ Value* Tune2FsFn(const char* name, State* state, const std::vector<std::unique_p
return StringValue("t"); return StringValue("t");
} }
Value* AddSlotSuffixFn(const char* name, State* state,
const std::vector<std::unique_ptr<Expr>>& argv) {
if (argv.size() != 1) {
return ErrorAbort(state, kArgsParsingFailure, "%s() expects 1 arg, got %zu", name, argv.size());
}
std::vector<std::string> args;
if (!ReadArgs(state, argv, &args)) {
return ErrorAbort(state, kArgsParsingFailure, "%s() Failed to parse the argument(s)", name);
}
const std::string& arg = args[0];
auto updater_runtime = state->updater->GetRuntime();
return StringValue(updater_runtime->AddSlotSuffix(arg));
}
void RegisterInstallFunctions() { void RegisterInstallFunctions() {
RegisterFunction("mount", MountFn); RegisterFunction("mount", MountFn);
RegisterFunction("is_mounted", IsMountedFn); RegisterFunction("is_mounted", IsMountedFn);
@@ -885,4 +899,6 @@ void RegisterInstallFunctions() {
RegisterFunction("enable_reboot", EnableRebootFn); RegisterFunction("enable_reboot", EnableRebootFn);
RegisterFunction("tune2fs", Tune2FsFn); RegisterFunction("tune2fs", Tune2FsFn);
RegisterFunction("add_slot_suffix", AddSlotSuffixFn);
} }
updater/simulator_runtime.cpp
+5
View File
@@ -130,3 +130,8 @@ bool SimulatorRuntime::UpdateDynamicPartitions(const std::string_view op_list_va
} }
return true; return true;
} }
std::string SimulatorRuntime::AddSlotSuffix(const std::string_view arg) const {
LOG(INFO) << "Skip adding slot suffix to " << arg;
return std::string(arg);
}
updater/updater_runtime.cpp
+5
View File
@@ -28,6 +28,7 @@
#include <android-base/strings.h> #include <android-base/strings.h>
#include <android-base/unique_fd.h> #include <android-base/unique_fd.h>
#include <ext4_utils/wipe.h> #include <ext4_utils/wipe.h>
#include <fs_mgr.h>
#include <selinux/label.h> #include <selinux/label.h>
#include <tune2fs.h> #include <tune2fs.h>
@@ -186,3 +187,7 @@ int UpdaterRuntime::Tune2Fs(const std::vector<std::string>& args) const {
// tune2fs changes the filesystem parameters on an ext2 filesystem; it returns 0 on success. // tune2fs changes the filesystem parameters on an ext2 filesystem; it returns 0 on success.
return tune2fs_main(tune2fs_args.size() - 1, tune2fs_args.data()); return tune2fs_main(tune2fs_args.size() - 1, tune2fs_args.data());
} }
std::string UpdaterRuntime::AddSlotSuffix(const std::string_view arg) const {
return std::string(arg) + fs_mgr_get_slot_suffix();
}
updater/updater_runtime_dynamic_partitions.cpp
+70 -57
View File
@@ -41,6 +41,7 @@ using android::fs_mgr::LpMetadata;
using android::fs_mgr::MetadataBuilder; using android::fs_mgr::MetadataBuilder;
using android::fs_mgr::Partition; using android::fs_mgr::Partition;
using android::fs_mgr::PartitionOpener; using android::fs_mgr::PartitionOpener;
using android::fs_mgr::SlotNumberForSlotSuffix;
static constexpr std::chrono::milliseconds kMapTimeout{ 1000 }; static constexpr std::chrono::milliseconds kMapTimeout{ 1000 };
@@ -48,13 +49,17 @@ static std::string GetSuperDevice() {
return "/dev/block/by-name/" + fs_mgr_get_super_partition_name(); return "/dev/block/by-name/" + fs_mgr_get_super_partition_name();
} }
static bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) { static std::string AddSlotSuffix(const std::string& partition_name) {
auto state = DeviceMapper::Instance().GetState(partition_name); return partition_name + fs_mgr_get_slot_suffix();
}
static bool UnmapPartitionWithSuffixOnDeviceMapper(const std::string& partition_name_suffix) {
auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
if (state == DmDeviceState::INVALID) { if (state == DmDeviceState::INVALID) {
return true; return true;
} }
if (state == DmDeviceState::ACTIVE) { if (state == DmDeviceState::ACTIVE) {
return DestroyLogicalPartition(partition_name); return DestroyLogicalPartition(partition_name_suffix);
} }
LOG(ERROR) << "Unknown device mapper state: " LOG(ERROR) << "Unknown device mapper state: "
<< static_cast<std::underlying_type_t<DmDeviceState>>(state); << static_cast<std::underlying_type_t<DmDeviceState>>(state);
@@ -63,12 +68,17 @@ static bool UnmapPartitionOnDeviceMapper(const std::string& partition_name) {
bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_name, bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_name,
std::string* path) { std::string* path) {
auto state = DeviceMapper::Instance().GetState(partition_name); auto partition_name_suffix = AddSlotSuffix(partition_name);
auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
if (state == DmDeviceState::INVALID) { if (state == DmDeviceState::INVALID) {
CreateLogicalPartitionParams params = { CreateLogicalPartitionParams params = {
.block_device = GetSuperDevice(), .block_device = GetSuperDevice(),
.metadata_slot = 0, // If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
.partition_name = partition_name, // SlotNumberForSlotSuffix("") returns 0.
.metadata_slot = SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix()),
// If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
// fs_mgr_get_slot_suffix() returns empty string.
.partition_name = partition_name_suffix,
.force_writable = true, .force_writable = true,
.timeout_ms = kMapTimeout, .timeout_ms = kMapTimeout,
}; };
@@ -76,7 +86,7 @@ bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_nam
} }
if (state == DmDeviceState::ACTIVE) { if (state == DmDeviceState::ACTIVE) {
return DeviceMapper::Instance().GetDmDevicePathByName(partition_name, path); return DeviceMapper::Instance().GetDmDevicePathByName(partition_name_suffix, path);
} }
LOG(ERROR) << "Unknown device mapper state: " LOG(ERROR) << "Unknown device mapper state: "
<< static_cast<std::underlying_type_t<DmDeviceState>>(state); << static_cast<std::underlying_type_t<DmDeviceState>>(state);
@@ -84,7 +94,7 @@ bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_nam
} }
bool UpdaterRuntime::UnmapPartitionOnDeviceMapper(const std::string& partition_name) { bool UpdaterRuntime::UnmapPartitionOnDeviceMapper(const std::string& partition_name) {
return ::UnmapPartitionOnDeviceMapper(partition_name); return ::UnmapPartitionWithSuffixOnDeviceMapper(AddSlotSuffix(partition_name));
} }
namespace { // Ops namespace { // Ops
@@ -126,22 +136,23 @@ using OpMap = std::map<std::string, OpFunction>;
bool PerformOpResize(const OpParameters& params) { bool PerformOpResize(const OpParameters& params) {
if (!params.ExpectArgSize(2)) return false; if (!params.ExpectArgSize(2)) return false;
const auto& partition_name = params.arg(0); const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
auto size = params.uint_arg(1, "size"); auto size = params.uint_arg(1, "size");
if (!size.has_value()) return false; if (!size.has_value()) return false;
auto partition = params.builder->FindPartition(partition_name); auto partition = params.builder->FindPartition(partition_name_suffix);
if (partition == nullptr) { if (partition == nullptr) {
LOG(ERROR) << "Failed to find partition " << partition_name LOG(ERROR) << "Failed to find partition " << partition_name_suffix
<< " in dynamic partition metadata."; << " in dynamic partition metadata.";
return false; return false;
} }
if (!UnmapPartitionOnDeviceMapper(partition_name)) { if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
LOG(ERROR) << "Cannot unmap " << partition_name << " before resizing."; LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before resizing.";
return false; return false;
} }
if (!params.builder->ResizePartition(partition, size.value())) { if (!params.builder->ResizePartition(partition, size.value())) {
LOG(ERROR) << "Failed to resize partition " << partition_name << " to size " << *size << "."; LOG(ERROR) << "Failed to resize partition " << partition_name_suffix << " to size " << *size
<< ".";
return false; return false;
} }
return true; return true;
@@ -149,24 +160,25 @@ bool PerformOpResize(const OpParameters& params) {
bool PerformOpRemove(const OpParameters& params) { bool PerformOpRemove(const OpParameters& params) {
if (!params.ExpectArgSize(1)) return false; if (!params.ExpectArgSize(1)) return false;
const auto& partition_name = params.arg(0); const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
if (!UnmapPartitionOnDeviceMapper(partition_name)) { if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
LOG(ERROR) << "Cannot unmap " << partition_name << " before removing."; LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing.";
return false; return false;
} }
params.builder->RemovePartition(partition_name); params.builder->RemovePartition(partition_name_suffix);
return true; return true;
} }
bool PerformOpAdd(const OpParameters& params) { bool PerformOpAdd(const OpParameters& params) {
if (!params.ExpectArgSize(2)) return false; if (!params.ExpectArgSize(2)) return false;
const auto& partition_name = params.arg(0); const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
const auto& group_name = params.arg(1); const auto& group_name_suffix = AddSlotSuffix(params.arg(1));
if (params.builder->AddPartition(partition_name, group_name, LP_PARTITION_ATTR_READONLY) == if (params.builder->AddPartition(partition_name_suffix, group_name_suffix,
nullptr) { LP_PARTITION_ATTR_READONLY) == nullptr) {
LOG(ERROR) << "Failed to add partition " << partition_name << " to group " << group_name << "."; LOG(ERROR) << "Failed to add partition " << partition_name_suffix << " to group "
<< group_name_suffix << ".";
return false; return false;
} }
return true; return true;
@@ -174,21 +186,21 @@ bool PerformOpAdd(const OpParameters& params) {
bool PerformOpMove(const OpParameters& params) { bool PerformOpMove(const OpParameters& params) {
if (!params.ExpectArgSize(2)) return false; if (!params.ExpectArgSize(2)) return false;
const auto& partition_name = params.arg(0); const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
const auto& new_group = params.arg(1); const auto& new_group_name_suffix = AddSlotSuffix(params.arg(1));
auto partition = params.builder->FindPartition(partition_name); auto partition = params.builder->FindPartition(partition_name_suffix);
if (partition == nullptr) { if (partition == nullptr) {
LOG(ERROR) << "Cannot move partition " << partition_name << " to group " << new_group LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " to group "
<< " because it is not found."; << new_group_name_suffix << " because it is not found.";
return false; return false;
} }
auto old_group = partition->group_name(); auto old_group_name_suffix = partition->group_name();
if (old_group != new_group) { if (old_group_name_suffix != new_group_name_suffix) {
if (!params.builder->ChangePartitionGroup(partition, new_group)) { if (!params.builder->ChangePartitionGroup(partition, new_group_name_suffix)) {
LOG(ERROR) << "Cannot move partition " << partition_name << " from group " << old_group LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " from group "
<< " to group " << new_group << "."; << old_group_name_suffix << " to group " << new_group_name_suffix << ".";
return false; return false;
} }
} }
@@ -197,22 +209,22 @@ bool PerformOpMove(const OpParameters& params) {
bool PerformOpAddGroup(const OpParameters& params) { bool PerformOpAddGroup(const OpParameters& params) {
if (!params.ExpectArgSize(2)) return false; if (!params.ExpectArgSize(2)) return false;
const auto& group_name = params.arg(0); const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
auto maximum_size = params.uint_arg(1, "maximum_size"); auto maximum_size = params.uint_arg(1, "maximum_size");
if (!maximum_size.has_value()) return false; if (!maximum_size.has_value()) return false;
auto group = params.builder->FindGroup(group_name); auto group = params.builder->FindGroup(group_name_suffix);
if (group != nullptr) { if (group != nullptr) {
LOG(ERROR) << "Cannot add group " << group_name << " because it already exists."; LOG(ERROR) << "Cannot add group " << group_name_suffix << " because it already exists.";
return false; return false;
} }
if (maximum_size.value() == 0) { if (maximum_size.value() == 0) {
LOG(WARNING) << "Adding group " << group_name << " with no size limits."; LOG(WARNING) << "Adding group " << group_name_suffix << " with no size limits.";
} }
if (!params.builder->AddGroup(group_name, maximum_size.value())) { if (!params.builder->AddGroup(group_name_suffix, maximum_size.value())) {
LOG(ERROR) << "Failed to add group " << group_name << " with maximum size " LOG(ERROR) << "Failed to add group " << group_name_suffix << " with maximum size "
<< maximum_size.value() << "."; << maximum_size.value() << ".";
return false; return false;
} }
@@ -221,20 +233,20 @@ bool PerformOpAddGroup(const OpParameters& params) {
bool PerformOpResizeGroup(const OpParameters& params) { bool PerformOpResizeGroup(const OpParameters& params) {
if (!params.ExpectArgSize(2)) return false; if (!params.ExpectArgSize(2)) return false;
const auto& group_name = params.arg(0); const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
auto new_size = params.uint_arg(1, "maximum_size"); auto new_size = params.uint_arg(1, "maximum_size");
if (!new_size.has_value()) return false; if (!new_size.has_value()) return false;
auto group = params.builder->FindGroup(group_name); auto group = params.builder->FindGroup(group_name_suffix);
if (group == nullptr) { if (group == nullptr) {
LOG(ERROR) << "Cannot resize group " << group_name << " because it is not found."; LOG(ERROR) << "Cannot resize group " << group_name_suffix << " because it is not found.";
return false; return false;
} }
auto old_size = group->maximum_size(); auto old_size = group->maximum_size();
if (old_size != new_size.value()) { if (old_size != new_size.value()) {
if (!params.builder->ChangeGroupSize(group_name, new_size.value())) { if (!params.builder->ChangeGroupSize(group_name_suffix, new_size.value())) {
LOG(ERROR) << "Cannot resize group " << group_name << " from " << old_size << " to " LOG(ERROR) << "Cannot resize group " << group_name_suffix << " from " << old_size << " to "
<< new_size.value() << "."; << new_size.value() << ".";
return false; return false;
} }
@@ -243,8 +255,8 @@ bool PerformOpResizeGroup(const OpParameters& params) {
} }
std::vector<std::string> ListPartitionNamesInGroup(MetadataBuilder* builder, std::vector<std::string> ListPartitionNamesInGroup(MetadataBuilder* builder,
const std::string& group_name) { const std::string& group_name_suffix) {
auto partitions = builder->ListPartitionsInGroup(group_name); auto partitions = builder->ListPartitionsInGroup(group_name_suffix);
std::vector<std::string> partition_names; std::vector<std::string> partition_names;
std::transform(partitions.begin(), partitions.end(), std::back_inserter(partition_names), std::transform(partitions.begin(), partitions.end(), std::back_inserter(partition_names),
[](Partition* partition) { return partition->name(); }); [](Partition* partition) { return partition->name(); });
@@ -253,15 +265,16 @@ std::vector<std::string> ListPartitionNamesInGroup(MetadataBuilder* builder,
bool PerformOpRemoveGroup(const OpParameters& params) { bool PerformOpRemoveGroup(const OpParameters& params) {
if (!params.ExpectArgSize(1)) return false; if (!params.ExpectArgSize(1)) return false;
const auto& group_name = params.arg(0); const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
auto partition_names = ListPartitionNamesInGroup(params.builder, group_name); auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
if (!partition_names.empty()) { if (!partition_names.empty()) {
LOG(ERROR) << "Cannot remove group " << group_name << " because it still contains partitions [" LOG(ERROR) << "Cannot remove group " << group_name_suffix
<< " because it still contains partitions ["
<< android::base::Join(partition_names, ", ") << "]"; << android::base::Join(partition_names, ", ") << "]";
return false; return false;
} }
params.builder->RemoveGroupAndPartitions(group_name); params.builder->RemoveGroupAndPartitions(group_name_suffix);
return true; return true;
} }
@@ -269,16 +282,16 @@ bool PerformOpRemoveAllGroups(const OpParameters& params) {
if (!params.ExpectArgSize(0)) return false; if (!params.ExpectArgSize(0)) return false;
auto group_names = params.builder->ListGroups(); auto group_names = params.builder->ListGroups();
for (const auto& group_name : group_names) { for (const auto& group_name_suffix : group_names) {
auto partition_names = ListPartitionNamesInGroup(params.builder, group_name); auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
for (const auto& partition_name : partition_names) { for (const auto& partition_name_suffix : partition_names) {
if (!UnmapPartitionOnDeviceMapper(partition_name)) { if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
LOG(ERROR) << "Cannot unmap " << partition_name << " before removing group " << group_name LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing group "
<< "."; << group_name_suffix << ".";
return false; return false;
} }
} }
params.builder->RemoveGroupAndPartitions(group_name); params.builder->RemoveGroupAndPartitions(group_name_suffix);
} }
return true; return true;
} }