Remove blob_pool::generate_reference_tag and related tests

This change is part of the remaining work for project-tsurugi/tsurugi-issues#1337

Author: umegane

include/limestone/api/blob_pool.h

@@ -91,21 +91,6 @@ class blob_pool {
      */
     [[nodiscard]] virtual blob_id_type duplicate_data(blob_id_type reference) = 0;
 
-    /**
-     * @brief generates a BLOB reference tag for access control.
-     * @param blob_id the BLOB reference
-     * @param transaction_id the transaction ID
-     * @return the generated BLOB reference tag
-     * @throws limestone_blob_exception if an internal error occurs during tag generation.
-     *         Possible reasons include:
-     *         - Environment issues (e.g., cryptographic library not initialized or misconfigured)
-     *         - Resource exhaustion (e.g., out of memory)
-     *         - Other unexpected internal errors
-     * @note No validation is performed for blob_id or transaction_id values; any value is accepted.
-     */
-    [[nodiscard]] virtual blob_reference_tag_type generate_reference_tag(
-            blob_id_type blob_id,
-            std::uint64_t transaction_id) = 0;
 };
 
 } // namespace limestone::api

src/limestone/blob_pool_impl.cpp

@@ -341,40 +341,4 @@ blob_id_type blob_pool_impl::register_data(std::string_view data) {
     return id;
 }
 
-blob_reference_tag_type blob_pool_impl::generate_reference_tag(
-    blob_id_type blob_id,
-    std::uint64_t transaction_id) {
-    
-    // Prepare input data: concatenate blob_id and transaction_id using portable approach
-    std::array<unsigned char, sizeof(blob_id_type) + sizeof(std::uint64_t)> input_bytes{};
-    std::memcpy(input_bytes.data(), &blob_id, sizeof(blob_id_type));
-    std::memcpy(input_bytes.data() + sizeof(blob_id_type), &transaction_id, sizeof(std::uint64_t));
-
-    // Get the secret key from datastore_impl
-    const auto& secret_key = datastore_.get_impl()->get_hmac_secret_key();
-
-    // Clear OpenSSL error queue to avoid noise from previous API calls
-    ERR_clear_error();
-
-    // Calculate HMAC-SHA256
-    std::array<unsigned char, EVP_MAX_MD_SIZE> md{};
-    unsigned int md_len = 0;
-
-    unsigned char* result = HMAC(EVP_sha256(), 
-                                secret_key.data(), 
-                                static_cast<int>(secret_key.size()),
-                                input_bytes.data(),
-                                input_bytes.size(),
-                                md.data(), 
-                                &md_len);
-
-    this->handle_hmac_result(result);
-
-    // Use the first 8 bytes of the HMAC result as the tag
-    blob_reference_tag_type tag = 0;
-    std::memcpy(&tag, md.data(), sizeof(blob_reference_tag_type));
-    
-    return tag;
-}
-
 } // namespace limestone::internal

src/limestone/blob_pool_impl.h

@@ -33,9 +33,6 @@ class blob_pool_impl : public blob_pool {
 
     [[nodiscard]] blob_id_type duplicate_data(blob_id_type reference) override;
 
-    [[nodiscard]] blob_reference_tag_type generate_reference_tag(
-        blob_id_type blob_id,
-        std::uint64_t transaction_id) override;
 
 protected:
     // These protected fields and methods include:

test/limestone/blob/blob_pool_impl_test.cpp

@@ -1424,53 +1424,4 @@ TEST_F(blob_pool_impl_test, handle_hmac_result_with_failed_hmac_throws) {
     }
 }
 
-
-
-TEST_F(blob_pool_impl_test, generate_reference_tag_deterministic_and_unique) {
-    blob_id_type blob_id1 = pool_->register_data("dummy1");
-    blob_id_type blob_id2 = pool_->register_data("dummy2");
-    std::uint64_t txid1 = 100;
-    std::uint64_t txid2 = 200;
-
-    // The same input yields the same tag
-    auto tag1a = pool_->generate_reference_tag(blob_id1, txid1);
-    auto tag1b = pool_->generate_reference_tag(blob_id1, txid1);
-    EXPECT_EQ(tag1a, tag1b);
-
-    // Different blob_id yields a different tag
-    auto tag2 = pool_->generate_reference_tag(blob_id2, txid1);
-    EXPECT_NE(tag1a, tag2);
-
-    // Different transaction_id yields a different tag
-    auto tag3 = pool_->generate_reference_tag(blob_id1, txid2);
-    EXPECT_NE(tag1a, tag3);
-}
-
-TEST_F(blob_pool_impl_test, generate_reference_tag_changes_after_datastore_restart) {
-    blob_id_type blob_id = pool_->register_data("dummy");
-    std::uint64_t txid = 12345;
-    auto tag_before = pool_->generate_reference_tag(blob_id, txid);
-
-    // Restart datastore
-    pool_.reset();
-    resolver_.reset();
-    datastore_->shutdown();
-    datastore_.reset();
-
-    // Create a new datastore/pool
-    std::vector<boost::filesystem::path> data_locations{base_directory};
-    boost::filesystem::path metadata_location_path{metadata_location};
-    limestone::api::configuration conf(data_locations, metadata_location_path);
-    datastore_ = std::make_unique<limestone::api::datastore>(conf);
-    resolver_ = std::make_unique<blob_file_resolver>(boost::filesystem::path(blob_directory));
-    pool_ = std::make_unique<testable_blob_pool_impl>(id_generator_, *resolver_, *datastore_);
-
-    auto tag_after = pool_->generate_reference_tag(blob_id, txid);
-
-    // The tag changes after datastore restart (because the HMAC secret key changes)
-    EXPECT_NE(tag_before, tag_after);
-}
-
-
-
 }  // namespace limestone::testing