samples(storagecontrol): add samples for anywhere cache

README.md

@@ -41,3 +41,7 @@ But no sample will work until you
 ## Testing
 
 * See [TESTING.md](TESTING.md)
+
+## Note
+
+Tests for the Anywhere Cache samples are not included because creating an AnywhereCache can take an extremely long time, sometimes up to 48 hours.

storage/api/Storage.Samples/StorageControlCreateAnywhereCache.cs

@@ -0,0 +1,56 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_create_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using Google.LongRunning;
+using System;
+
+public class StorageControlCreateAnywhereCacheSample
+{
+    /// <summary>Creates an anywhere cache instance in the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket.</param>
+    /// <param name="zoneName">The name of the zone in which the cache instance will run.</param>
+    public Operation<AnywhereCache, CreateAnywhereCacheMetadata> StorageControlCreateAnywhereCache(string bucketName = "your-unique-bucket-name",
+        string zoneName = "us-east1-b")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string parent = $"projects/_/buckets/{bucketName}";
+
+        AnywhereCache anywhereCache = new AnywhereCache
+        {
+            Zone = zoneName
+        };
+
+        var request = new CreateAnywhereCacheRequest
+        {
+            AnywhereCache = anywhereCache,
+            Parent = parent
+        };
+
+        // Start a long-running operation (LRO).
+        Operation<AnywhereCache, CreateAnywhereCacheMetadata> createdCacheOperation = storageControlClient.CreateAnywhereCache(request);
+
+        // Await the LROs completion.
+        var createdCache = createdCacheOperation.PollUntilCompleted();
+
+        Console.WriteLine($"Created Anywhere Cache Instance: {createdCache.Result.AnywhereCacheName}");
+
+        return createdCache;
+    }
+}
+// [END storage_control_create_anywhere_cache]

storage/api/Storage.Samples/StorageControlDisableAnywhereCache.cs

@@ -0,0 +1,45 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_disable_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using System;
+
+public class StorageControlDisableAnywhereCacheSample
+{
+    /// <summary>Disables the anywhere cache instance in the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="anywhereCacheId">The unique identifier of the cache instance to disable.</param>
+    public AnywhereCache StorageControlDisableAnywhereCache(string bucketName = "your-unique-bucket-name",
+        string anywhereCacheId = "us-east1-b")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string anywhereCacheName = $"projects/_/buckets/{bucketName}/anywhereCaches/{anywhereCacheId}";
+
+        var request = new DisableAnywhereCacheRequest
+        {
+            Name = anywhereCacheName
+        };
+
+        AnywhereCache disabledCache = storageControlClient.DisableAnywhereCache(request);
+
+        Console.WriteLine($"Disabled Anywhere Cache Instance: {disabledCache.Name}");
+
+        return disabledCache;
+    }
+}
+// [END storage_control_disable_anywhere_cache]

storage/api/Storage.Samples/StorageControlGetAnywhereCache.cs

@@ -0,0 +1,45 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_get_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using System;
+
+public class StorageControlGetAnywhereCacheSample
+{
+    /// <summary>Gets an anywhere cache instance for the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="anywhereCacheId">The unique identifier of the cache instance.</param>
+    public AnywhereCache StorageControlGetAnywhereCache(string bucketName = "your-unique-bucket-name",
+        string anywhereCacheId = "us-east1-b")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string anywhereCacheName = $"projects/_/buckets/{bucketName}/anywhereCaches/{anywhereCacheId}";
+
+        var request = new GetAnywhereCacheRequest
+        {
+            Name = anywhereCacheName
+        };
+
+        AnywhereCache retrievedCache = storageControlClient.GetAnywhereCache(request);
+
+        Console.WriteLine($"Got Anywhere Cache Instance: {retrievedCache.Name}");
+
+        return retrievedCache;
+    }
+}
+// [END storage_control_get_anywhere_cache]

storage/api/Storage.Samples/StorageControlListAnywhereCaches.cs

@@ -0,0 +1,62 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_list_anywhere_caches]
+
+using Google.Api.Gax;
+using Google.Cloud.Storage.Control.V2;
+using System;
+using System.Collections.Generic;
+
+public class StorageControlListAnywhereCachesSample
+{
+    /// <summary>Lists all anywhere cache instances for the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="pageSize">The maximum number of anywhere cache instances to return in a single response.</param>
+    public IEnumerable<AnywhereCache> StorageControlListAnywhereCaches(string bucketName = "your-unique-bucket-name", int pageSize = 10)
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string parent = $"projects/_/buckets/{bucketName}";
+
+        var request = new ListAnywhereCachesRequest
+        {
+            Parent = parent,
+            PageSize = pageSize
+        };
+
+        PagedEnumerable<ListAnywhereCachesResponse, AnywhereCache> anywhereCaches = storageControlClient.ListAnywhereCaches(request);
+
+        Console.WriteLine($"The Names of Anywhere Cache Instances are as follows:");
+
+        foreach (AnywhereCache cache in anywhereCaches)
+        {
+            Console.WriteLine($"Anywhere Cache Instance: {cache.Name}");
+        }
+
+        // Retrieve a single page of page size (unless it's the final page).
+        Page<AnywhereCache> singlePage = anywhereCaches.ReadPage(pageSize);
+
+        Console.WriteLine($"The Names of Anywhere Cache Instances in the Page of Page Size {pageSize} are as follows:");
+
+        foreach (AnywhereCache cache in singlePage)
+        {
+            Console.WriteLine($"Anywhere Cache Instance: {cache.Name}");
+        }
+
+        return anywhereCaches;
+    }
+}
+// [END storage_control_list_anywhere_caches]

storage/api/Storage.Samples/StorageControlPauseAnywhereCache.cs

@@ -0,0 +1,45 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_pause_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using System;
+
+public class StorageControlPauseAnywhereCacheSample
+{
+    /// <summary>Pauses an anywhere cache instance in the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="anywhereCacheId">The unique identifier of the cache instance to pause.</param>
+    public AnywhereCache StorageControlPauseAnywhereCache(string bucketName = "your-unique-bucket-name",
+        string anywhereCacheId = "us-east1-b")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string anywhereCacheName = $"projects/_/buckets/{bucketName}/anywhereCaches/{anywhereCacheId}";
+
+        var request = new PauseAnywhereCacheRequest
+        {
+            Name = anywhereCacheName
+        };
+
+        AnywhereCache pausedCache = storageControlClient.PauseAnywhereCache(request);
+
+        Console.WriteLine($"Paused Anywhere Cache Instance: {pausedCache.Name}");
+
+        return pausedCache;
+    }
+}
+// [END storage_control_pause_anywhere_cache]

storage/api/Storage.Samples/StorageControlResumeAnywhereCache.cs

@@ -0,0 +1,45 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_resume_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using System;
+
+public class StorageControlResumeAnywhereCacheSample
+{
+    /// <summary>Resumes the disabled or paused anywhere cache instance in the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="anywhereCacheId">The unique identifier of the cache instance to resume.</param>
+    public AnywhereCache StorageControlResumeAnywhereCache(string bucketName = "your-unique-bucket-name",
+        string anywhereCacheId = "us-east1-b")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string anywhereCacheName = $"projects/_/buckets/{bucketName}/anywhereCaches/{anywhereCacheId}";
+
+        var request = new ResumeAnywhereCacheRequest
+        {
+            Name = anywhereCacheName
+        };
+
+        AnywhereCache resumedCache = storageControlClient.ResumeAnywhereCache(request);
+
+        Console.WriteLine($"Resumed Anywhere Cache Instance: {resumedCache.Name}");
+
+        return resumedCache;
+    }
+}
+// [END storage_control_resume_anywhere_cache]

storage/api/Storage.Samples/StorageControlUpdateAnywhereCache.cs

@@ -0,0 +1,61 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+// https://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.
+
+// [START storage_control_update_anywhere_cache]
+
+using Google.Cloud.Storage.Control.V2;
+using Google.LongRunning;
+using Google.Protobuf.WellKnownTypes;
+using System;
+
+public class StorageControlUpdateAnywhereCacheSample
+{
+    /// <summary>Updates the running anywhere cache instance for the specified bucket.</summary>
+    /// <param name="bucketName">The name of the bucket that owns the anywhere cache instance.</param>
+    /// <param name="anywhereCacheId">The unique identifier of the cache instance to update.</param>
+    /// <param name="admissionPolicy"> The cache's admission policy. Values can be admit-on-first-miss or admit-on-second-miss. If not specified, it defaults to admit-on-first-miss.</param>
+    public Operation<AnywhereCache, UpdateAnywhereCacheMetadata> StorageControlUpdateAnywhereCache(string bucketName = "your-bucket-name",
+        string anywhereCacheId = "us-east1-b",
+        string admissionPolicy = "admit-on-first-miss")
+    {
+        StorageControlClient storageControlClient = StorageControlClient.Create();
+
+        // Set project to "_" to signify globally scoped bucket.
+        string anywhereCacheName = $"projects/_/buckets/{bucketName}/anywhereCaches/{anywhereCacheId}";
+
+        var anywhereCache = new AnywhereCache
+        {
+            Name = anywhereCacheName,
+            AdmissionPolicy = admissionPolicy
+        };
+        FieldMask fieldMask = new FieldMask { Paths = { "admission_policy" } };
+
+        var request = new UpdateAnywhereCacheRequest
+        {
+            AnywhereCache = anywhereCache,
+            UpdateMask = fieldMask
+        };
+
+        // Start a long-running operation (LRO).
+        Operation<AnywhereCache, UpdateAnywhereCacheMetadata> updatedCacheOperation = storageControlClient.UpdateAnywhereCache(request);
+
+        // Await the LROs completion.
+        var updatedCache = updatedCacheOperation.PollUntilCompleted();
+
+        Console.WriteLine($"Updated Anywhere Cache Instance: {updatedCache.Result.Name}, New Cache Admission Policy: {updatedCache.Result.AdmissionPolicy}");
+
+        return updatedCache;
+    }
+}
+// [END storage_control_update_anywhere_cache]