Build datastore index resource.

.changelog/3085.txt

@@ -0,0 +1,4 @@
+```release-note:new-resource
+google_datastore_index
+
+```

google-beta/access_context_manager_operation.go

@@ -14,6 +14,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 )
 
@@ -31,15 +32,37 @@ func (w *AccessContextManagerOperationWaiter) QueryOp() (interface{}, error) {
 	return sendRequest(w.Config, "GET", "", url, nil)
 }
 
-func accessContextManagerOperationWaitTime(config *Config, op map[string]interface{}, activity string, timeoutMinutes int) error {
+func createAccessContextManagerWaiter(config *Config, op map[string]interface{}, activity string) (*AccessContextManagerOperationWaiter, error) {
 	if val, ok := op["name"]; !ok || val == "" {
 		// This was a synchronous call - there is no operation to wait for.
-		return nil
+		return nil, nil
 	}
 	w := &AccessContextManagerOperationWaiter{
 		Config: config,
 	}
 	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func accessContextManagerOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, activity string, timeoutMinutes int) error {
+	w, err := createAccessContextManagerWaiter(config, op, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func accessContextManagerOperationWaitTime(config *Config, op map[string]interface{}, activity string, timeoutMinutes int) error {
+	w, err := createAccessContextManagerWaiter(config, op, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
 		return err
 	}
 	return OperationWait(w, activity, timeoutMinutes)

google-beta/appengine_operation.go

@@ -1,6 +1,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 	"regexp"
 
@@ -32,6 +33,27 @@ func appEngineOperationWait(config *Config, res interface{}, appId, activity str
 	return appEngineOperationWaitTime(config, res, appId, activity, 4)
 }
 
+func appEngineOperationWaitTimeWithResponse(config *Config, res interface{}, response *map[string]interface{}, appId, activity string, timeoutMinutes int) error {
+	op := &appengine.Operation{}
+	err := Convert(res, op)
+	if err != nil {
+		return err
+	}
+
+	w := &AppEngineOperationWaiter{
+		Service: config.clientAppEngine,
+		AppId:   appId,
+	}
+
+	if err := w.SetOp(op); err != nil {
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
 func appEngineOperationWaitTime(config *Config, res interface{}, appId, activity string, timeoutMinutes int) error {
 	op := &appengine.Operation{}
 	err := Convert(res, op)

google-beta/config.go

@@ -90,6 +90,7 @@ type Config struct {
 	ContainerAnalysisBasePath    string
 	DataFusionBasePath           string
 	DataprocBasePath             string
+	DatastoreBasePath            string
 	DeploymentManagerBasePath    string
 	DialogflowBasePath           string
 	DNSBasePath                  string
@@ -233,6 +234,7 @@ var ComputeDefaultBasePath = "https://www.googleapis.com/compute/beta/"
 var ContainerAnalysisDefaultBasePath = "https://containeranalysis.googleapis.com/v1beta1/"
 var DataFusionDefaultBasePath = "https://datafusion.googleapis.com/v1beta1/"
 var DataprocDefaultBasePath = "https://dataproc.googleapis.com/v1beta2/"
+var DatastoreDefaultBasePath = "https://datastore.googleapis.com/v1/"
 var DeploymentManagerDefaultBasePath = "https://www.googleapis.com/deploymentmanager/v2/"
 var DialogflowDefaultBasePath = "https://dialogflow.googleapis.com/v2/"
 var DNSDefaultBasePath = "https://www.googleapis.com/dns/v1beta2/"
@@ -734,6 +736,7 @@ func ConfigureBasePaths(c *Config) {
 	c.ContainerAnalysisBasePath = ContainerAnalysisDefaultBasePath
 	c.DataFusionBasePath = DataFusionDefaultBasePath
 	c.DataprocBasePath = DataprocDefaultBasePath
+	c.DatastoreBasePath = DatastoreDefaultBasePath
 	c.DeploymentManagerBasePath = DeploymentManagerDefaultBasePath
 	c.DialogflowBasePath = DialogflowDefaultBasePath
 	c.DNSBasePath = DNSDefaultBasePath

google-beta/data_fusion_operation.go

@@ -14,6 +14,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 )
 
@@ -32,16 +33,38 @@ func (w *DataFusionOperationWaiter) QueryOp() (interface{}, error) {
 	return sendRequest(w.Config, "GET", w.Project, url, nil)
 }
 
-func dataFusionOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+func createDataFusionWaiter(config *Config, op map[string]interface{}, project, activity string) (*DataFusionOperationWaiter, error) {
 	if val, ok := op["name"]; !ok || val == "" {
 		// This was a synchronous call - there is no operation to wait for.
-		return nil
+		return nil, nil
 	}
 	w := &DataFusionOperationWaiter{
 		Config:  config,
 		Project: project,
 	}
 	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func dataFusionOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createDataFusionWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func dataFusionOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createDataFusionWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
 		return err
 	}
 	return OperationWait(w, activity, timeoutMinutes)

google-beta/datastore_operation.go

@@ -0,0 +1,71 @@
+// ----------------------------------------------------------------------------
+//
+//     ***     AUTO GENERATED CODE    ***    AUTO GENERATED CODE     ***
+//
+// ----------------------------------------------------------------------------
+//
+//     This file is automatically generated by Magic Modules and manual
+//     changes will be clobbered when the file is regenerated.
+//
+//     Please read more about how to change this file in
+//     .github/CONTRIBUTING.md.
+//
+// ----------------------------------------------------------------------------
+package google
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type DatastoreOperationWaiter struct {
+	Config  *Config
+	Project string
+	CommonOperationWaiter
+}
+
+func (w *DatastoreOperationWaiter) QueryOp() (interface{}, error) {
+	if w == nil {
+		return nil, fmt.Errorf("Cannot query operation, it's unset or nil.")
+	}
+	// Returns the proper get.
+	url := fmt.Sprintf("https://datastore.googleapis.com/v1/%s", w.CommonOperationWaiter.Op.Name)
+	return sendRequest(w.Config, "GET", w.Project, url, nil)
+}
+
+func createDatastoreWaiter(config *Config, op map[string]interface{}, project, activity string) (*DatastoreOperationWaiter, error) {
+	if val, ok := op["name"]; !ok || val == "" {
+		// This was a synchronous call - there is no operation to wait for.
+		return nil, nil
+	}
+	w := &DatastoreOperationWaiter{
+		Config:  config,
+		Project: project,
+	}
+	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func datastoreOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createDatastoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func datastoreOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createDatastoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	return OperationWait(w, activity, timeoutMinutes)
+}

google-beta/filestore_operation.go

@@ -14,6 +14,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 )
 
@@ -32,16 +33,38 @@ func (w *FilestoreOperationWaiter) QueryOp() (interface{}, error) {
 	return sendRequest(w.Config, "GET", w.Project, url, nil)
 }
 
-func filestoreOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+func createFilestoreWaiter(config *Config, op map[string]interface{}, project, activity string) (*FilestoreOperationWaiter, error) {
 	if val, ok := op["name"]; !ok || val == "" {
 		// This was a synchronous call - there is no operation to wait for.
-		return nil
+		return nil, nil
 	}
 	w := &FilestoreOperationWaiter{
 		Config:  config,
 		Project: project,
 	}
 	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func filestoreOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createFilestoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func filestoreOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createFilestoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
 		return err
 	}
 	return OperationWait(w, activity, timeoutMinutes)

google-beta/firestore_operation.go

@@ -14,6 +14,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 )
 
@@ -32,16 +33,38 @@ func (w *FirestoreOperationWaiter) QueryOp() (interface{}, error) {
 	return sendRequest(w.Config, "GET", w.Project, url, nil)
 }
 
-func firestoreOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+func createFirestoreWaiter(config *Config, op map[string]interface{}, project, activity string) (*FirestoreOperationWaiter, error) {
 	if val, ok := op["name"]; !ok || val == "" {
 		// This was a synchronous call - there is no operation to wait for.
-		return nil
+		return nil, nil
 	}
 	w := &FirestoreOperationWaiter{
 		Config:  config,
 		Project: project,
 	}
 	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func firestoreOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createFirestoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func firestoreOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createFirestoreWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
 		return err
 	}
 	return OperationWait(w, activity, timeoutMinutes)

google-beta/ml_engine_operation.go

@@ -14,6 +14,7 @@
 package google
 
 import (
+	"encoding/json"
 	"fmt"
 )
 
@@ -32,16 +33,38 @@ func (w *MLEngineOperationWaiter) QueryOp() (interface{}, error) {
 	return sendRequest(w.Config, "GET", w.Project, url, nil)
 }
 
-func mLEngineOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+func createMLEngineWaiter(config *Config, op map[string]interface{}, project, activity string) (*MLEngineOperationWaiter, error) {
 	if val, ok := op["name"]; !ok || val == "" {
 		// This was a synchronous call - there is no operation to wait for.
-		return nil
+		return nil, nil
 	}
 	w := &MLEngineOperationWaiter{
 		Config:  config,
 		Project: project,
 	}
 	if err := w.CommonOperationWaiter.SetOp(op); err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+// nolint: deadcode,unused
+func mLEngineOperationWaitTimeWithResponse(config *Config, op map[string]interface{}, response *map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createMLEngineWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
+		return err
+	}
+	if err := OperationWait(w, activity, timeoutMinutes); err != nil {
+		return err
+	}
+	return json.Unmarshal([]byte(w.CommonOperationWaiter.Op.Response), response)
+}
+
+func mLEngineOperationWaitTime(config *Config, op map[string]interface{}, project, activity string, timeoutMinutes int) error {
+	w, err := createMLEngineWaiter(config, op, project, activity)
+	if err != nil || w == nil {
+		// If w is nil, the op was synchronous.
 		return err
 	}
 	return OperationWait(w, activity, timeoutMinutes)