wgtmac commented on code in PR #509:
URL: https://github.com/apache/iceberg-cpp/pull/509#discussion_r2697535420
##########
src/iceberg/util/snapshot_util.cc:
##########
@@ -116,7 +145,7 @@ Result<std::optional<std::shared_ptr<Snapshot>>>
SnapshotUtil::OldestAncestorAft
std::optional<std::shared_ptr<Snapshot>> last_snapshot = std::nullopt;
ICEBERG_ASSIGN_OR_RAISE(auto ancestors, AncestorsOf(table, current));
- for (const auto& snapshot : ancestors) {
Review Comment:
Let's revert this change.
##########
src/iceberg/type_fwd.h:
##########
@@ -194,6 +194,7 @@ class UpdateProperties;
class UpdateSchema;
class UpdateSortOrder;
class ExpireSnapshots;
+class SetSnapshot;
Review Comment:
Put it before SnapshotUpdate
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToInvalidSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->RollbackTo(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("unknown snapshot id"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeValidOldestSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a time between the two snapshots
+ // This should select the oldest snapshot
+ int64_t time_between = (kOldestSnapshotTimestamp +
kCurrentSnapshotTimestamp) / 2;
+ set_snapshot->RollbackToTime(time_between);
+
+ // Apply and verify
Review Comment:
```suggestion
```
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToInvalidSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->RollbackTo(invalid_snapshot_id);
+
+ // Should fail during Apply
Review Comment:
```suggestion
```
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToInvalidSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->RollbackTo(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("unknown snapshot id"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeValidOldestSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a time between the two snapshots
+ // This should select the oldest snapshot
+ int64_t time_between = (kOldestSnapshotTimestamp +
kCurrentSnapshotTimestamp) / 2;
+ set_snapshot->RollbackToTime(time_between);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeBeforeAnySnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a time before any snapshot
+ int64_t time_before_all = kOldestSnapshotTimestamp - 1000000;
+ set_snapshot->RollbackToTime(time_before_all);
+
+ // Should fail - no snapshot older than the specified time
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("no valid snapshot older than"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeExactMatch) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a timestamp just after the oldest snapshot
+ // This should return the oldest snapshot (the latest one before this time)
Review Comment:
```suggestion
```
##########
src/iceberg/update/set_snapshot.cc:
##########
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+#include "iceberg/snapshot.h"
+#include "iceberg/table_metadata.h"
+#include "iceberg/transaction.h"
+#include "iceberg/util/error_collector.h"
+#include "iceberg/util/macros.h"
+#include "iceberg/util/snapshot_util_internal.h"
+#include "iceberg/util/timepoint.h"
+
+namespace iceberg {
+
+Result<std::shared_ptr<SetSnapshot>> SetSnapshot::Make(
+ std::shared_ptr<Transaction> transaction) {
+ ICEBERG_PRECHECK(transaction != nullptr,
+ "Cannot create SetSnapshot without a transaction");
+ return std::shared_ptr<SetSnapshot>(new SetSnapshot(std::move(transaction)));
+}
+
+SetSnapshot::SetSnapshot(std::shared_ptr<Transaction> transaction)
+ : PendingUpdate(std::move(transaction)) {}
+
+SetSnapshot::~SetSnapshot() = default;
+
+SetSnapshot& SetSnapshot::SetCurrentSnapshot(int64_t snapshot_id) {
+ // Validate that the snapshot exists
+ ICEBERG_BUILDER_ASSIGN_OR_RETURN(auto snapshot,
base().SnapshotById(snapshot_id));
+ ICEBERG_BUILDER_CHECK(snapshot != nullptr,
+ "Cannot roll back to unknown snapshot id: {}",
snapshot_id);
+ target_snapshot_id_ = snapshot_id;
+ return *this;
+}
+
+SetSnapshot& SetSnapshot::RollbackToTime(int64_t timestamp_ms) {
+ // Find the latest snapshot by timestamp older than timestamp_ms
+ ICEBERG_BUILDER_ASSIGN_OR_RETURN(auto snapshot_opt,
+ FindLatestAncestorOlderThan(timestamp_ms));
+
+ ICEBERG_BUILDER_CHECK(snapshot_opt.has_value(),
+ "Cannot roll back, no valid snapshot older than: {}",
+ timestamp_ms);
+
+ target_snapshot_id_ = snapshot_opt.value()->snapshot_id;
+ is_rollback_ = true;
+
+ return *this;
+}
+
+SetSnapshot& SetSnapshot::RollbackTo(int64_t snapshot_id) {
+ // Validate that the snapshot exists
+ auto snapshot_result = base().SnapshotById(snapshot_id);
+ ICEBERG_BUILDER_CHECK(snapshot_result.has_value(),
+ "Cannot roll back to unknown snapshot id: {}",
snapshot_id);
+
+ // Validate that the snapshot is an ancestor of the current state
+ ICEBERG_BUILDER_ASSIGN_OR_RETURN(bool is_ancestor,
+ SnapshotUtil::IsAncestorOf(base(),
snapshot_id));
+ ICEBERG_BUILDER_CHECK(
+ is_ancestor,
+ "Cannot roll back to snapshot, not an ancestor of the current state: {}",
+ snapshot_id);
+
+ return SetCurrentSnapshot(snapshot_id);
+}
+
+Result<int64_t> SetSnapshot::Apply() {
+ ICEBERG_RETURN_UNEXPECTED(CheckErrors());
+
+ const TableMetadata& base_metadata = transaction_->current();
+
+ // If no target snapshot was configured, return current state (NOOP)
+ if (!target_snapshot_id_.has_value()) {
+ ICEBERG_ASSIGN_OR_RAISE(auto current_snapshot, base_metadata.Snapshot());
+ return current_snapshot->snapshot_id;
+ }
+
+ // Validate that the snapshot exists
+ auto snapshot_result =
base_metadata.SnapshotById(target_snapshot_id_.value());
+ ICEBERG_CHECK(snapshot_result.has_value(),
+ "Cannot roll back to unknown snapshot id: {}",
+ target_snapshot_id_.value());
+
+ // If this is a rollback, validate that the target is still an ancestor
+ if (is_rollback_) {
+ ICEBERG_ASSIGN_OR_RAISE(
+ bool is_ancestor,
+ SnapshotUtil::IsAncestorOf(base_metadata,
target_snapshot_id_.value()));
+ ICEBERG_CHECK(is_ancestor,
+ "Cannot roll back to {}: not an ancestor of the current
table state",
+ target_snapshot_id_.value());
+ }
+
+ return target_snapshot_id_.value();
+}
+
+Result<std::optional<std::shared_ptr<Snapshot>>>
SetSnapshot::FindLatestAncestorOlderThan(
+ int64_t timestamp_ms) const {
+ ICEBERG_ASSIGN_OR_RAISE(auto ancestors,
SnapshotUtil::CurrentAncestors(base()));
+
+ TimePointMs target_timestamp = TimePointMsFromUnixMs(timestamp_ms);
+ TimePointMs latest_timestamp = TimePointMsFromUnixMs(0);
+ std::shared_ptr<Snapshot> result = nullptr;
+
+ for (auto& snapshot : ancestors) {
+ if (snapshot == nullptr) {
+ continue;
+ }
+ auto current_timestamp = snapshot->timestamp_ms;
+ if (current_timestamp < target_timestamp && current_timestamp >
latest_timestamp) {
+ latest_timestamp = current_timestamp; // Save timestamp before move
Review Comment:
I think this function can return `Result<std::optional<int64_t>` now.
##########
src/iceberg/util/snapshot_util.cc:
##########
@@ -86,6 +102,19 @@ Result<std::vector<std::shared_ptr<Snapshot>>>
SnapshotUtil::CurrentAncestors(
return AncestorsOf(table, current_result.value());
}
+Result<std::vector<std::shared_ptr<Snapshot>>> SnapshotUtil::CurrentAncestors(
+ const TableMetadata& metadata) {
+ auto current_result = metadata.Snapshot();
+ ICEBERG_ACTION_FOR_NOT_FOUND(current_result, return {});
Review Comment:
Shouldn't we return the error as is if current snapshot is missing? The
current approach may confuse the caller that the current snapshot exists but it
does not have any ancestor.
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToInvalidSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->RollbackTo(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("unknown snapshot id"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeValidOldestSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a time between the two snapshots
+ // This should select the oldest snapshot
+ int64_t time_between = (kOldestSnapshotTimestamp +
kCurrentSnapshotTimestamp) / 2;
+ set_snapshot->RollbackToTime(time_between);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeBeforeAnySnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a time before any snapshot
+ int64_t time_before_all = kOldestSnapshotTimestamp - 1000000;
+ set_snapshot->RollbackToTime(time_before_all);
+
+ // Should fail - no snapshot older than the specified time
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("no valid snapshot older than"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeExactMatch) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a timestamp just after the oldest snapshot
+ // This should return the oldest snapshot (the latest one before this time)
+ int64_t time_just_after_oldest = kOldestSnapshotTimestamp + 1;
+ set_snapshot->RollbackToTime(time_just_after_oldest);
+
+ // Apply and verify - should return the oldest snapshot
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, ApplyWithoutChanges) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Apply without making any changes (NOOP)
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+
+ // Should return current snapshot
Review Comment:
```suggestion
ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
```
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToInvalidSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->RollbackTo(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("unknown snapshot id"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeValidOldestSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a time between the two snapshots
+ // This should select the oldest snapshot
+ int64_t time_between = (kOldestSnapshotTimestamp +
kCurrentSnapshotTimestamp) / 2;
+ set_snapshot->RollbackToTime(time_between);
+
+ // Apply and verify
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeBeforeAnySnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to rollback to a time before any snapshot
+ int64_t time_before_all = kOldestSnapshotTimestamp - 1000000;
+ set_snapshot->RollbackToTime(time_before_all);
+
+ // Should fail - no snapshot older than the specified time
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("no valid snapshot older than"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToTimeExactMatch) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to a timestamp just after the oldest snapshot
+ // This should return the oldest snapshot (the latest one before this time)
+ int64_t time_just_after_oldest = kOldestSnapshotTimestamp + 1;
+ set_snapshot->RollbackToTime(time_just_after_oldest);
+
+ // Apply and verify - should return the oldest snapshot
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, ApplyWithoutChanges) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Apply without making any changes (NOOP)
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+
+ // Should return current snapshot
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+
+ // Commit NOOP and verify nothing changed
Review Comment:
```suggestion
```
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
Review Comment:
```suggestion
```
##########
src/iceberg/test/set_snapshot_test.cc:
##########
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/update/set_snapshot.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/snapshot.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/update_test_base.h"
+#include "iceberg/transaction.h"
+
+namespace iceberg {
+
+// Test fixture for SetSnapshot tests
+class SetSnapshotTest : public UpdateTestBase {
+ protected:
+ // Snapshot IDs from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotId = 3051729675574597004;
+ static constexpr int64_t kCurrentSnapshotId = 3055729675574597004;
+
+ // Timestamps from TableMetadataV2Valid.json
+ static constexpr int64_t kOldestSnapshotTimestamp = 1515100955770;
+ static constexpr int64_t kCurrentSnapshotTimestamp = 1555100955770;
+};
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ EXPECT_EQ(set_snapshot->kind(), PendingUpdate::Kind::kSetSnapshot);
+
+ set_snapshot->SetCurrentSnapshot(kOldestSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kOldestSnapshotId);
+
+ // Commit and verify the change was persisted
+ EXPECT_THAT(set_snapshot->Commit(), IsOk());
+ ICEBERG_UNWRAP_OR_FAIL(auto reloaded, catalog_->LoadTable(table_ident_));
+ ICEBERG_UNWRAP_OR_FAIL(auto current_snapshot, reloaded->current_snapshot());
+ EXPECT_EQ(current_snapshot->snapshot_id, kOldestSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotToCurrentSnapshot) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ set_snapshot->SetCurrentSnapshot(kCurrentSnapshotId);
+
+ ICEBERG_UNWRAP_OR_FAIL(auto snapshot_id, set_snapshot->Apply());
+ EXPECT_EQ(snapshot_id, kCurrentSnapshotId);
+}
+
+TEST_F(SetSnapshotTest, SetCurrentSnapshotInvalid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Try to set to a non-existent snapshot
+ int64_t invalid_snapshot_id = 9999999999999999;
+ set_snapshot->SetCurrentSnapshot(invalid_snapshot_id);
+
+ // Should fail during Apply
+ auto result = set_snapshot->Apply();
+ EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+ EXPECT_THAT(result, HasErrorMessage("is not found"));
+}
+
+TEST_F(SetSnapshotTest, RollbackToValid) {
+ ICEBERG_UNWRAP_OR_FAIL(auto set_snapshot, table_->NewSetSnapshot());
+ // Rollback to the oldest snapshot (which is an ancestor)
+ set_snapshot->RollbackTo(kOldestSnapshotId);
+
+ // Apply and verify
Review Comment:
```suggestion
```
##########
src/iceberg/table.h:
##########
@@ -151,6 +151,10 @@ class ICEBERG_EXPORT Table : public
std::enable_shared_from_this<Table> {
/// changes.
virtual Result<std::shared_ptr<ExpireSnapshots>> NewExpireSnapshots();
+ /// \brief Create a new SetSnapshot to set the current snapshot or rollback
to a
+ /// previous snapshot and commit the changes.
+ virtual Result<std::shared_ptr<SetSnapshot>> NewSetSnapshot();
Review Comment:
Please remove this since the Java impl only adds to transaction not table.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
