Adds google_storage_anywhere_cache resource

Author: googlyrahman

mmv1/products/storage/AnywhereCache.yaml

@@ -0,0 +1,97 @@
+# Copyright 2025 Google Inc.
+# 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
+#
+#     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.
+
+---
+name: 'AnywhereCache'
+kind: 'storage#anywhereCache'
+description: |
+  The Google Cloud Storage (GCS) Anywhere Cache feature allows users to
+  create SSD backed zonal read cache for their buckets. These zonal
+  caches are co-located with the customers compute engines to provide
+  cost efficiency. 
+base_url: 'b/{{bucket}}/anywhereCaches'
+self_link: 'b/{{bucket}}/anywhereCaches/{{anywhere_cache_id}}'
+create_url: 'b/{{bucket}}/anywhereCaches/'
+delete_url: 'b/{{bucket}}/anywhereCaches/{{anywhere_cache_id}}/disable'
+update_verb: 'PATCH'
+delete_verb: 'POST'
+import_format: ['b/{{bucket}}/anywhereCaches/{{anywhere_cache_id}}']
+id_format: '{{bucket}}/{{anywhere_cache_id}}'
+identity:
+  - bucket
+  - anywhereCacheId
+custom_code:
+  custom_create: templates/terraform/custom_create/storage_anywhere_cache_custom_create.go.tmpl
+autogen_async: false
+timeouts:
+  insert_minutes: 240
+  update_minutes: 240
+  delete_minutes: 20
+async:
+  type: 'OpAsync'
+  actions:
+    - create
+    - update
+  operation:
+    full_url: 'selfLink'
+  result:
+    resource_inside_response: true
+parameters:
+  - name: 'bucket'
+    type: ResourceRef
+    required: true
+    immutable: true
+    url_param_only: true 
+    resource: 'Bucket'
+    imports: 'name'   
+properties:
+  - name: 'zone'
+    type: String
+    required: true
+    immutable: true
+    description: The zone in which the cache instance needs to be created. For example, `us-central1-a.`
+  - name: 'admissionPolicy'
+    type: Enum
+    enum_values:
+      - 'admit-on-first-miss'
+      - 'admit-on-second-miss'
+    default_value: 'admit-on-first-miss'
+    description: The cache admission policy dictates whether a block should be inserted upon a cache miss.
+  - name: 'ttl'
+    type: String
+    default_value: '86400s'
+    description: The TTL of all cache entries in whole seconds. e.g., "7200s". It defaults to `86400s`
+  - name: 'anywhereCacheId'
+    type: String
+    output: true
+    description: The ID of the Anywhere cache instance.
+  - name: 'createTime'
+    type: Time
+    output: true
+    description: The creation time of the cache instance in RFC 3339 format.
+  - name: 'updateTime'
+    type: Time
+    output: true
+    description: The modification time of the cache instance metadata in RFC 3339 format.
+  - name: 'id'
+    type: String
+    output: true
+    description: The ID of the resource, it is in format of `{bucket_name}/{anywhere_cache_id}`
+  - name: 'pendingUpdate'
+    type: Boolean
+    output: true
+    description: True if the cache instance has an active Update long-running operation.
+  - name: 'state'
+    type: String
+    output: true
+    description: The current state of the cache instance.

mmv1/templates/terraform/custom_create/storage_anywhere_cache_custom_create.go.tmpl

@@ -0,0 +1,98 @@
+userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
+if err != nil {
+    return err
+}
+
+obj := make(map[string]interface{})
+admissionPolicyProp, err := expandStorageAnywhereCacheAdmissionPolicy(d.Get("admission_policy"), d, config)
+if err != nil {
+    return err
+} else if v, ok := d.GetOkExists("admission_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(admissionPolicyProp)) && (ok || !reflect.DeepEqual(v, admissionPolicyProp)) {
+    obj["admissionPolicy"] = admissionPolicyProp
+}
+ttlProp, err := expandStorageAnywhereCacheTtl(d.Get("ttl"), d, config)
+if err != nil {
+    return err
+} else if v, ok := d.GetOkExists("ttl"); !tpgresource.IsEmptyValue(reflect.ValueOf(ttlProp)) && (ok || !reflect.DeepEqual(v, ttlProp)) {
+    obj["ttl"] = ttlProp
+}
+zoneProp, err := expandStorageAnywhereCacheZone(d.Get("zone"), d, config)
+if err != nil {
+    return err
+} else if v, ok := d.GetOkExists("zone"); !tpgresource.IsEmptyValue(reflect.ValueOf(zoneProp)) && (ok || !reflect.DeepEqual(v, zoneProp)) {
+    obj["zone"] = zoneProp
+}
+
+url, err := tpgresource.ReplaceVars(d, config, "{{"{{StorageBasePath}}b/{{bucket}}/anywhereCaches/"}}")
+if err != nil {
+    return err
+}
+
+log.Printf("[DEBUG] Creating new AnywhereCache: %#v", obj)
+billingProject := ""
+
+// err == nil indicates that the billing_project value was found
+if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
+    billingProject = bp
+}
+
+headers := make(http.Header)
+res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
+    Config:    config,
+    Method:    "POST",
+    Project:   billingProject,
+    RawURL:    url,
+    UserAgent: userAgent,
+    Body:      obj,
+    Timeout:   d.Timeout(schema.TimeoutCreate),
+    Headers:   headers,
+})
+if err != nil {
+    return fmt.Errorf("Error creating AnywhereCache: %s", err)
+}
+
+// Store the ID now
+id, err := tpgresource.ReplaceVars(d, config, "{{"b/{{bucket}}/anywhereCaches/{{anywhere_cache_id}}"}}")
+if err != nil {
+    return fmt.Errorf("Error constructing id: %s", err)
+}
+d.SetId(id)
+
+// Use the resource in the operation response to populate
+// identity fields and d.Id() before read
+var opRes map[string]interface{}
+err = StorageOperationWaitTimeWithResponse(
+    config, res, &opRes, "Creating AnywhereCache", userAgent,
+    d.Timeout(schema.TimeoutCreate))
+if err != nil {
+    // The resource didn't actually create
+    d.SetId("")
+
+    return fmt.Errorf("Error waiting to create AnywhereCache: %s", err)
+}
+
+nameVal, ok := opRes["name"].(string)
+if !ok {
+    return fmt.Errorf("opRes['name'] is not a string: %v", opRes["name"])
+}
+
+nameParts := strings.Split(nameVal, "/")
+if len(nameParts) != 6 || nameParts[0] != "projects" || nameParts[2] != "buckets" || nameParts[4] != "anywhereCaches" {
+    return fmt.Errorf("error parsing the anywhereCacheId from %s", nameVal)
+}
+
+anywhereCacheID := nameParts[5]
+if err := d.Set("anywhere_cache_id", anywhereCacheID); err != nil {
+    return err
+}
+
+// This may have caused the ID to update - update it if so.
+id, err = tpgresource.ReplaceVars(d, config, "{{"b/{{bucket}}/anywhereCaches/{{anywhere_cache_id}}"}}")
+if err != nil {
+    return fmt.Errorf("Error constructing id: %s", err)
+}
+d.SetId(id)
+
+log.Printf("[DEBUG] Finished creating AnywhereCache %q: %#v", d.Id(), res)
+
+return resourceStorageAnywhereCacheRead(d, meta)