[sahusneha2004]

Adds Storage Control Rapid Cache samples for Java:

Sample	Region tag
RapidCacheCreate	storage_control_create_rapid_cache
RapidCacheGet	storage_control_get_rapid_cache
RapidCacheList	storage_control_list_rapid_caches
RapidCacheUpdate	storage_control_update_rapid_cache
RapidCacheDisable	storage_control_disable_rapid_cache

Notes:

• Create uses cache_type = "rapid-cache-ultra" and does not set a name; the server assigns the cache ID (currently equal to the zone).
• Update sets ttl = 172800s with update mask ["ttl"].
• Disable starts the LRO and prints the operation name without waiting: the cache enters the disabled state within seconds, but the operation only completes once the cache is fully removed (can take more than 30 minutes).
• Bumps libraries-bom 26.78.0 → 26.90.0 (google-cloud-storage-control 2.75.0, which includes RapidCache), and the matching google-cloud-storage versions (tests jar and install-without-bom) 2.64.0 → 2.75.0.

Testing:

• ITRapidCacheTest runs create → get → list → update, then disable in finally, and polls get until the state is disabled. It uses a regional HNS + UBLA bucket in the zone's region. Zone defaults to us-central1-a and can be overridden with RAPID_CACHE_ZONE.
• Like ITAnywhereCacheTest, the test is skipped in CI (JOB_TYPE set) because of the long operation times. It passed when run locally against an allowlisted project.
• Bucket cleanup is best-effort: deleting the bucket returns 409 ("The bucket you tried to delete has Rapid Cache Ultra") for a long time after disable, so the test retries for about 2 minutes and then leaves the bucket for the stale-bucket cleanup.

b/482946642

[Generated-by: AI]

Update: aligned with #14529

The samples now match the API usage in the reference integration test (ITRapidCacheTest in #14529). Where this section differs from the notes above, this section is current.

Samples:

• RapidCacheCreate: sets the name explicitly to projects/_/buckets/{bucket}/rapidCaches/{zone} (the backend requires the cache ID to equal the zone), plus zone, cache_type = "rapid-cache-ultra" and ttl = 86400s (24h). Prints the name, cache type and state.
• RapidCacheGet: also prints the cache type.
• RapidCacheDisable: now waits for the LRO (disableRapidCacheAsync(request).get()) and prints the result, the same as the reference. A comment explains that the cache is disabled within seconds, but full removal can take longer than the client's default polling timeout (5 minutes).
• Region tags are unchanged.

Test (ITRapidCacheTest):

• Waits 20s after creating the HNS + UBLA bucket so its metadata can propagate.
• Uses cache ID = zone and checks the exact cache name.
• Create: checks the cache type. Get: checks State: running and the cache type. List: checks that the cache is listed. Update: checks TTL: 172800 seconds.
• Disable: runs the sample with a 10-minute limit. If the wait times out, or the client stops polling (CancellationException), the test checks that get shows State: disabled and does not fail.
• Teardown: if the test did not disable the cache, it starts a disable and ignores errors. It then tries to delete the bucket and logs the name of any bucket it leaves behind.
• CI skip (JOB_TYPE) and zone default/override are unchanged.
• Passed in a live run against an allowlisted project (about 7.5 min).

[gemini-code-assist]

Code Review

This pull request introduces code snippets and integration tests for managing Rapid Cache in Google Cloud Storage Control v2, including creation, retrieval, listing, updating, and disabling operations, alongside updating the necessary Maven dependencies. The review feedback focuses on improving the robustness and readability of the integration tests by moving the Rapid Cache disabling logic into the tearDown method, declaring cacheId as an instance field, and simplifying the test flow by removing the complex manual try-catch-finally block.

[gemini-code-assist]

Declare cacheId as an instance field so that it can be accessed in the tearDown method for robust cleanup, even if the test fails before reaching the manual cleanup block.

Suggested change

	private String bucketName;
	private int outputOffset;
	private String bucketName;
	private String cacheId;
	private int outputOffset;

[gemini-code-assist]

Update the tearDown method to automatically disable the Rapid Cache if cacheId is set. This ensures that resources are cleaned up reliably even if assertions or other operations in the test fail.

  @After
  public void tearDown() throws InterruptedException {
    if (bucketName == null) {
      return;
    }
    if (cacheId != null) {
      try {
        RapidCacheDisable.rapidCacheDisable(bucketName, cacheId);
      } catch (Exception e) {
        System.err.printf("Failed to disable Rapid Cache %s: %s%n", cacheId, e.getMessage());
      }
    }
    // Best-effort cleanup. A bucket with a Rapid Cache cannot be deleted until the cache has been
    // fully removed, which can take a long time after it is disabled. Any leftover bucket is
    // removed by the stale bucket cleanup.
    long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(BUCKET_DELETE_TIMEOUT_SECONDS);
    while (true) {
      try {
        storage.delete(bucketName);
        return;
      } catch (StorageException e) {
        if (e.getCode() != 409 || System.nanoTime() > deadline) {
          System.err.printf("Leaving bucket %s for cleanup: %s%n", bucketName, e.getMessage());
          return;
        }
        TimeUnit.SECONDS.sleep(BUCKET_DELETE_INTERVAL_SECONDS);
      }
    }
  }

References

1. In test cleanup or resource deletion logic, catching a broad Exception is acceptable to ensure that the cleanup process is not halted by individual failures.

[gemini-code-assist]

Simplify the test method by removing the complex manual try-catch-finally block. Since cleanup is now handled in tearDown, we can write a clean, linear test flow. We also set cacheId = null at the end of the test to prevent double-disabling in tearDown.

  @Test
  public void createGetListUpdateDisable() throws Exception {
    // Test create Rapid Cache
    RapidCacheCreate.rapidCacheCreate(bucketName, ZONE.getZone());
    String out = newOutput();
    assertThat(out).contains(CREATED_PREFIX);
    String cacheName = 
        out.substring(out.indexOf(CREATED_PREFIX) + CREATED_PREFIX.length()).trim().split("\\s")[0];
    cacheId = RapidCacheName.parse(cacheName).getRapidCache();
    assertThat(cacheId).isNotEmpty();

    // Test get Rapid Cache
    RapidCacheGet.rapidCacheGet(bucketName, cacheId);
    out = newOutput();
    assertThat(out).contains(cacheName);
    assertThat(out).contains("Zone: " + ZONE.getZone());
    assertThat(out).contains("State: ");

    // Test list Rapid Caches
    RapidCacheList.rapidCacheList(bucketName);
    assertThat(newOutput()).contains(cacheName);

    // Test update Rapid Cache
    RapidCacheUpdate.rapidCacheUpdate(bucketName, cacheId, 172800);
    out = newOutput();
    assertThat(out).contains("Updated Rapid Cache: " + cacheName);
    assertThat(out).contains("TTL: 172800 seconds");

    // Test disable Rapid Cache
    RapidCacheDisable.rapidCacheDisable(bucketName, cacheId);
    String disableOut = newOutput();
    assertThat(disableOut).contains("Disabling Rapid Cache: " + cacheName);
    assertThat(disableOut).contains("Operation: ");

    // The cache moves to the "disabled" state shortly after the request.
    for (int i = 0; i < DISABLE_POLL_ATTEMPTS; i++) {
      RapidCacheGet.rapidCacheGet(bucketName, cacheId);
      out = newOutput();
      if (out.contains("State: disabled")) {
        break;
      }
      TimeUnit.SECONDS.sleep(DISABLE_POLL_INTERVAL_SECONDS);
    }
    assertThat(out).contains("State: disabled");
    cacheId = null; // Prevent double-disabling in tearDown
  }

References

1. In integration tests, prioritize consistency and readability with existing test patterns (such as sequential client teardown) over complex nested try-finally blocks, unless a repository-wide cleanup is being performed.

[nidhiii-27]

Please regenerate java-storage/README.md via librarian generate — this is critical so merging the PR does not break the post-submit Librarian - Generate libraries check on main.

[nidhiii-27]

Please remove changes in this file, we do not modify these files directly, they are autgenerated.

[nidhiii-27]

Please remove changes from this file, we do not edit these files manually.

[nidhiii-27]

Please rename this variable to cacheId as followed across other samples (RapidCacheGet, RapidCacheUpdate)

[nidhiii-27]

In AnywhereCacheCreate.java, AnywhereCacheCreate only sets the required fields (.setName(...).setZone(zoneName)) and leaves TTL configuration to AnywhereCacheUpdate. Let's follow the same here.

[nidhiii-27]

Instead of spawning a single-threaded ExecutorService and waiting for DISABLE_TIMEOUT_MINUTES (10 minutes), we can simply call RapidCacheDisable.rapidCacheDisable(bucketName, cacheId) directly and catch ExecutionException when caused by CancellationException

Suggested change

	ExecutorService executor = Executors.newSingleThreadExecutor();
	try {
	Future<?> disable =
	executor.submit(
	() -> {
	RapidCacheDisable.rapidCacheDisable(bucketName, cacheId);
	return null;
	});
	try {
	disable.get(DISABLE_TIMEOUT_MINUTES, TimeUnit.MINUTES);
	cacheDisabled = true;
	assertThat(newOutput()).contains("Disabled Rapid Cache: " + cacheName);
	} catch (TimeoutException | ExecutionException e) {
	// A TimeoutException means our wait expired. A CancellationException means the client
	// stopped polling the operation (the default LRO polling timeout is 5 minutes). In both
	// cases the operation is still running on the server, and the cache must already be in
	// the "disabled" state. Any other error fails the test.
	if (e instanceof ExecutionException && !(e.getCause() instanceof CancellationException)) {
	throw e;
	}
	// Cancelling the local wait does not cancel the operation on the server.
	disable.cancel(true);
	cacheDisabled = true;
	newOutput();
	RapidCacheGet.rapidCacheGet(bucketName, cacheId);
	assertThat(newOutput()).contains("State: disabled");
	}
	} finally {
	executor.shutdownNow();
	}
	// Test disable Rapid Cache. The client's default LRO polling timeout is 5 minutes, whereas full
	// cache removal can take over an hour, though the cache enters the "disabled" state within
	// seconds.
	try {
	RapidCacheDisable.rapidCacheDisable(bucketName, cacheId);
	cacheDisabled = true;
	assertThat(newOutput()).contains("Disabled Rapid Cache: " + cacheName);
	} catch (ExecutionException e) {
	if (!(e.getCause() instanceof CancellationException)) {
	throw e;
	}
	cacheDisabled = true;
	newOutput();
	RapidCacheGet.rapidCacheGet(bucketName, cacheId);
	assertThat(newOutput()).contains("State: disabled");
	}

[nidhiii-27]

nit: Boolean variables should use positive names to avoid inverted logic like !cacheDisabled as per go/java-practices/naming#positive-booleans and go/tott-387

Suggested change

	private boolean cacheDisabled;
	private boolean cacheActive;