func (c *client) StartInstance(project, zone, name string) error {
	op, err := c.Retry(c.raw.Instances.Start(project, zone, name).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}
StartInstance starts a GCE instance.
package compute
import (
	"context"
	"fmt"
	"math/rand"
	"net/http"
	"strings"
	"time"
	"golang.org/x/oauth2"
	computeAlpha "google.golang.org/api/compute/v0.alpha"
	computeBeta "google.golang.org/api/compute/v0.beta"
	"google.golang.org/api/compute/v1"
	"google.golang.org/api/googleapi"
	"google.golang.org/api/option"
	"google.golang.org/api/transport"
)
type Client interface {
	AttachDisk(project, zone, instance string, d *compute.AttachedDisk) error
	DetachDisk(project, zone, instance, disk string) error
	CreateDisk(project, zone string, d *compute.Disk) error
	CreateDiskAlpha(project, zone string, d *computeAlpha.Disk) error
	CreateDiskBeta(project, zone string, d *computeBeta.Disk) error
	CreateForwardingRule(project, region string, fr *compute.ForwardingRule) error
	CreateFirewallRule(project string, i *compute.Firewall) error
	CreateImage(project string, i *compute.Image) error
	CreateImageAlpha(project string, i *computeAlpha.Image) error
	CreateImageBeta(project string, i *computeBeta.Image) error
	CreateInstance(project, zone string, i *compute.Instance) error
	CreateInstanceAlpha(project, zone string, i *computeAlpha.Instance) error
	CreateInstanceBeta(project, zone string, i *computeBeta.Instance) error
	CreateNetwork(project string, n *compute.Network) error
	CreateSnapshot(project, zone, disk string, s *compute.Snapshot) error
	CreateSubnetwork(project, region string, n *compute.Subnetwork) error
	CreateTargetInstance(project, zone string, ti *compute.TargetInstance) error
	DeleteDisk(project, zone, name string) error
	DeleteForwardingRule(project, region, name string) error
	DeleteFirewallRule(project, name string) error
	DeleteImage(project, name string) error
	DeleteInstance(project, zone, name string) error
	StartInstance(project, zone, name string) error
	StopInstance(project, zone, name string) error
	DeleteNetwork(project, name string) error
	DeleteSubnetwork(project, region, name string) error
	DeleteTargetInstance(project, zone, name string) error
	DeprecateImage(project, name string, deprecationstatus *compute.DeprecationStatus) error
	DeprecateImageAlpha(project, name string, deprecationstatus *computeAlpha.DeprecationStatus) error
	GetMachineType(project, zone, machineType string) (*compute.MachineType, error)
	GetProject(project string) (*compute.Project, error)
	GetSerialPortOutput(project, zone, name string, port, start int64) (*compute.SerialPortOutput, error)
	GetZone(project, zone string) (*compute.Zone, error)
	GetInstance(project, zone, name string) (*compute.Instance, error)
	GetInstanceAlpha(project, zone, name string) (*computeAlpha.Instance, error)
	GetInstanceBeta(project, zone, name string) (*computeBeta.Instance, error)
	GetDisk(project, zone, name string) (*compute.Disk, error)
	GetDiskAlpha(project, zone, name string) (*computeAlpha.Disk, error)
	GetDiskBeta(project, zone, name string) (*computeBeta.Disk, error)
	GetForwardingRule(project, region, name string) (*compute.ForwardingRule, error)
	GetFirewallRule(project, name string) (*compute.Firewall, error)
	GetGuestAttributes(project, zone, name, queryPath, variableKey string) (*compute.GuestAttributes, error)
	GetImage(project, name string) (*compute.Image, error)
	GetImageAlpha(project, name string) (*computeAlpha.Image, error)
	GetImageBeta(project, name string) (*computeBeta.Image, error)
	GetImageFromFamily(project, family string) (*compute.Image, error)
	GetLicense(project, name string) (*compute.License, error)
	GetNetwork(project, name string) (*compute.Network, error)
	GetSubnetwork(project, region, name string) (*compute.Subnetwork, error)
	GetTargetInstance(project, zone, name string) (*compute.TargetInstance, error)
	InstanceStatus(project, zone, name string) (string, error)
	InstanceStopped(project, zone, name string) (bool, error)
	ListMachineTypes(project, zone string, opts ...ListCallOption) ([]*compute.MachineType, error)
	ListLicenses(project string, opts ...ListCallOption) ([]*compute.License, error)
	ListZones(project string, opts ...ListCallOption) ([]*compute.Zone, error)
	ListRegions(project string, opts ...ListCallOption) ([]*compute.Region, error)
	AggregatedListInstances(project string, opts ...ListCallOption) ([]*compute.Instance, error)
	ListInstances(project, zone string, opts ...ListCallOption) ([]*compute.Instance, error)
	AggregatedListDisks(project string, opts ...ListCallOption) ([]*compute.Disk, error)
	ListDisks(project, zone string, opts ...ListCallOption) ([]*compute.Disk, error)
	ListForwardingRules(project, zone string, opts ...ListCallOption) ([]*compute.ForwardingRule, error)
	ListFirewallRules(project string, opts ...ListCallOption) ([]*compute.Firewall, error)
	ListImages(project string, opts ...ListCallOption) ([]*compute.Image, error)
	ListImagesAlpha(project string, opts ...ListCallOption) ([]*computeAlpha.Image, error)
	GetSnapshot(project, name string) (*compute.Snapshot, error)
	ListSnapshots(project string, opts ...ListCallOption) ([]*compute.Snapshot, error)
	DeleteSnapshot(project, name string) error
	ListNetworks(project string, opts ...ListCallOption) ([]*compute.Network, error)
	AggregatedListSubnetworks(project string, opts ...ListCallOption) ([]*compute.Subnetwork, error)
	ListSubnetworks(project, region string, opts ...ListCallOption) ([]*compute.Subnetwork, error)
	ListTargetInstances(project, zone string, opts ...ListCallOption) ([]*compute.TargetInstance, error)
	ResizeDisk(project, zone, disk string, drr *compute.DisksResizeRequest) error
	SetInstanceMetadata(project, zone, name string, md *compute.Metadata) error
	SetCommonInstanceMetadata(project string, md *compute.Metadata) error
	SetDiskAutoDelete(project, zone, instance string, autoDelete bool, deviceName string) error
	ListMachineImages(project string, opts ...ListCallOption) ([]*computeBeta.MachineImage, error)
	DeleteMachineImage(project, name string) error
	CreateMachineImage(project string, i *computeBeta.MachineImage) error
	GetMachineImage(project, name string) (*computeBeta.MachineImage, error)
	Retry(f func(opts ...googleapi.CallOption) (*compute.Operation, error), opts ...googleapi.CallOption) (op *compute.Operation, err error)
	RetryBeta(f func(opts ...googleapi.CallOption) (*computeBeta.Operation, error), opts ...googleapi.CallOption) (op *computeBeta.Operation, err error)
	BasePath() string
}
type ListCallOption interface {
	listCallOptionApply(interface{}) interface{}
}
type OrderBy string
func (o OrderBy) listCallOptionApply(i interface{}) interface{} {
	switch c := i.(type) {
	case *compute.FirewallsListCall:
		return c.OrderBy(string(o))
	case *computeAlpha.ImagesListCall:
		return c.OrderBy(string(o))
	case *compute.ImagesListCall:
		return c.OrderBy(string(o))
	case *computeAlpha.MachineImagesListCall:
		return c.OrderBy(string(o))
	case *computeBeta.MachineImagesListCall:
		return c.OrderBy(string(o))
	case *compute.MachineTypesListCall:
		return c.OrderBy(string(o))
	case *compute.ZonesListCall:
		return c.OrderBy(string(o))
	case *compute.InstancesListCall:
		return c.OrderBy(string(o))
	case *compute.DisksListCall:
		return c.OrderBy(string(o))
	case *compute.NetworksListCall:
		return c.OrderBy(string(o))
	case *compute.SubnetworksListCall:
		return c.OrderBy(string(o))
	case *compute.InstancesAggregatedListCall:
		return c.OrderBy(string(o))
	case *compute.DisksAggregatedListCall:
		return c.OrderBy(string(o))
	case *compute.SubnetworksAggregatedListCall:
		return c.OrderBy(string(o))
	}
	return i
}
type Filter string
func (o Filter) listCallOptionApply(i interface{}) interface{} {
	switch c := i.(type) {
	case *compute.FirewallsListCall:
		return c.Filter(string(o))
	case *computeAlpha.ImagesListCall:
		return c.Filter(string(o))
	case *compute.ImagesListCall:
		return c.Filter(string(o))
	case *computeAlpha.MachineImagesListCall:
		return c.Filter(string(o))
	case *computeBeta.MachineImagesListCall:
		return c.Filter(string(o))
	case *compute.MachineTypesListCall:
		return c.Filter(string(o))
	case *compute.ZonesListCall:
		return c.Filter(string(o))
	case *compute.InstancesListCall:
		return c.Filter(string(o))
	case *compute.DisksListCall:
		return c.Filter(string(o))
	case *compute.NetworksListCall:
		return c.Filter(string(o))
	case *compute.SubnetworksListCall:
		return c.Filter(string(o))
	case *compute.InstancesAggregatedListCall:
		return c.Filter(string(o))
	case *compute.DisksAggregatedListCall:
		return c.Filter(string(o))
	case *compute.SubnetworksAggregatedListCall:
		return c.Filter(string(o))
	}
	return i
}
type clientImpl interface {
	Client
	zoneOperationsWait(project, zone, name string) error
	regionOperationsWait(project, region, name string) error
	globalOperationsWait(project, name string) error
}
type client struct {
	i        clientImpl
	hc       *http.Client
	raw      *compute.Service
	rawBeta  *computeBeta.Service
	rawAlpha *computeAlpha.Service
}
func shouldRetryWithWait(tripper http.RoundTripper, err error, multiplier int) bool {
	if err == nil {
		return false
	}
	tkValid := true
	trans, ok := tripper.(*oauth2.Transport)
	if ok {
		if tk, err := trans.Source.Token(); err == nil {
			tkValid = tk.Valid()
		}
	}
	apiErr, ok := err.(*googleapi.Error)
	var retry bool
	switch {
	case !ok && (strings.Contains(err.Error(), "connection reset by peer") || strings.Contains(err.Error(), "unexpected EOF")):
		retry = true
	case !ok && (strings.Contains(err.Error(), "server sent GOAWAY") || strings.Contains(err.Error(), "ENHANCE_YOUR_CALM")):
		multiplier = multiplier * 2
		retry = true
	case !ok && tkValid:
		return false
	case apiErr.Code >= 500 && apiErr.Code <= 599:
		retry = true
	case apiErr.Code >= 429:
		retry = true
	case apiErr.Code == 403 && strings.Contains(err.Error(), "rateLimitExceeded"):
		retry = true
	case !tkValid:
		retry = true
	}
	if !retry {
		return false
	}
	sleep := (time.Duration(rand.Intn(1000))*time.Millisecond + 1*time.Second) * time.Duration(multiplier)
	time.Sleep(sleep)
	return true
}
func NewClient(ctx context.Context, opts ...option.ClientOption) (Client, error) {
	o := []option.ClientOption{
		option.WithScopes(
			compute.CloudPlatformScope,
			compute.ComputeScope,
			compute.ComputeReadonlyScope,
			compute.DevstorageFullControlScope,
			compute.DevstorageReadOnlyScope,
			compute.DevstorageReadWriteScope,
		),
	}
	opts = append(o, opts...)
	hc, ep, err := transport.NewHTTPClient(ctx, opts...)
	if err != nil {
		return nil, fmt.Errorf("error creating HTTP API client: %v", err)
	}
	rawService, err := compute.New(hc)
	if err != nil {
		return nil, fmt.Errorf("compute client: %v", err)
	}
	if ep != "" {
		rawService.BasePath = ep
	}
	rawBetaService, err := computeBeta.New(hc)
	if err != nil {
		return nil, fmt.Errorf("beta compute client: %v", err)
	}
	if ep != "" {
		rawBetaService.BasePath = ep
	}
	rawAlphaService, err := computeAlpha.New(hc)
	if err != nil {
		return nil, fmt.Errorf("alpha compute client: %v", err)
	}
	if ep != "" {
		rawAlphaService.BasePath = ep
	}
	c := &client{hc: hc, raw: rawService, rawBeta: rawBetaService, rawAlpha: rawAlphaService}
	c.i = c
	return c, nil
}
func (c *client) BasePath() string {
	return c.raw.BasePath
}
type operationGetterFunc func() (*compute.Operation, error)
func (c *client) zoneOperationsWait(project, zone, name string) error {
	return c.operationsWaitHelper(project, name, func() (op *compute.Operation, err error) {
		op, err = c.Retry(c.raw.ZoneOperations.Wait(project, zone, name).Do)
		if err != nil {
			err = fmt.Errorf("failed to get zone operation %s: %v", name, err)
		}
		return op, err
	})
}
func (c *client) regionOperationsWait(project, region, name string) error {
	return c.operationsWaitHelper(project, name, func() (op *compute.Operation, err error) {
		op, err = c.Retry(c.raw.RegionOperations.Wait(project, region, name).Do)
		if err != nil {
			err = fmt.Errorf("failed to get region operation %s: %v", name, err)
		}
		return op, err
	})
}
func (c *client) globalOperationsWait(project, name string) error {
	return c.operationsWaitHelper(project, name, func() (op *compute.Operation, err error) {
		op, err = c.Retry(c.raw.GlobalOperations.Wait(project, name).Do)
		if err != nil {
			err = fmt.Errorf("failed to get global operation %s: %v", name, err)
		}
		return op, err
	})
}
var OperationErrorCodeFormat = "Code: %s"
var operationErrorMessageFormat = "Message: %s"
func (c *client) operationsWaitHelper(project, name string, getOperation operationGetterFunc) error {
	for {
		op, err := getOperation()
		if err != nil {
			return err
		}
		switch op.Status {
		case "PENDING", "RUNNING":
			time.Sleep(1 * time.Second)
			continue
		case "DONE":
			if op.Error != nil {
				var operrs string
				for _, operr := range op.Error.Errors {
					operrs = operrs + fmt.Sprintf(
						fmt.Sprintf("\n%v\n%v", OperationErrorCodeFormat, operationErrorMessageFormat),
						operr.Code, operr.Message)
				}
				return fmt.Errorf("operation failed %+v: %s", op, operrs)
			}
		default:
			return fmt.Errorf("unknown operation status %q: %+v", op.Status, op)
		}
		return nil
	}
}
func (c *client) Retry(f func(opts ...googleapi.CallOption) (*compute.Operation, error), opts ...googleapi.CallOption) (op *compute.Operation, err error) {
	for i := 1; i < 4; i++ {
		op, err = f(opts...)
		if err == nil {
			return op, nil
		}
		if !shouldRetryWithWait(c.hc.Transport, err, i) {
			return nil, err
		}
	}
	return
}
func (c *client) RetryBeta(f func(opts ...googleapi.CallOption) (*computeBeta.Operation, error), opts ...googleapi.CallOption) (op *computeBeta.Operation, err error) {
	for i := 1; i < 4; i++ {
		op, err = f(opts...)
		if err == nil {
			return op, nil
		}
		if !shouldRetryWithWait(c.hc.Transport, err, i) {
			return nil, err
		}
	}
	return
}
func (c *client) RetryAlpha(f func(opts ...googleapi.CallOption) (*computeAlpha.Operation, error), opts ...googleapi.CallOption) (op *computeAlpha.Operation, err error) {
	for i := 1; i < 4; i++ {
		op, err = f(opts...)
		if err == nil {
			return op, nil
		}
		if !shouldRetryWithWait(c.hc.Transport, err, i) {
			return nil, err
		}
	}
	return
}
func (c *client) AttachDisk(project, zone, instance string, d *compute.AttachedDisk) error {
	op, err := c.Retry(c.raw.Instances.AttachDisk(project, zone, instance, d).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}
func (c *client) DetachDisk(project, zone, instance, disk string) error {
	op, err := c.Retry(c.raw.Instances.DetachDisk(project, zone, instance, disk).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}
func (c *client) CreateDisk(project, zone string, d *compute.Disk) error {
	op, err := c.Retry(c.raw.Disks.Insert(project, zone, d).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdDisk *compute.Disk
	if createdDisk, err = c.i.GetDisk(project, zone, d.Name); err != nil {
		return err
	}
	*d = *createdDisk
	return nil
}
func (c *client) CreateDiskAlpha(project, zone string, d *computeAlpha.Disk) error {
	op, err := c.RetryAlpha(c.rawAlpha.Disks.Insert(project, zone, d).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdDisk *computeAlpha.Disk
	if createdDisk, err = c.i.GetDiskAlpha(project, zone, d.Name); err != nil {
		return err
	}
	*d = *createdDisk
	return nil
}
func (c *client) CreateDiskBeta(project, zone string, d *computeBeta.Disk) error {
	op, err := c.RetryBeta(c.rawBeta.Disks.Insert(project, zone, d).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdDisk *computeBeta.Disk
	if createdDisk, err = c.i.GetDiskBeta(project, zone, d.Name); err != nil {
		return err
	}
	*d = *createdDisk
	return nil
}
func (c *client) CreateForwardingRule(project, region string, fr *compute.ForwardingRule) error {
	op, err := c.Retry(c.raw.ForwardingRules.Insert(project, region, fr).Do)
	if err != nil {
		return err
	}
	if err := c.i.regionOperationsWait(project, region, op.Name); err != nil {
		return err
	}
	var createdForwardingRule *compute.ForwardingRule
	if createdForwardingRule, err = c.i.GetForwardingRule(project, region, fr.Name); err != nil {
		return err
	}
	*fr = *createdForwardingRule
	return nil
}
func (c *client) CreateFirewallRule(project string, i *compute.Firewall) error {
	op, err := c.Retry(c.raw.Firewalls.Insert(project, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.globalOperationsWait(project, op.Name); err != nil {
		return err
	}
	var createdFirewallRule *compute.Firewall
	if createdFirewallRule, err = c.i.GetFirewallRule(project, i.Name); err != nil {
		return err
	}
	*i = *createdFirewallRule
	return nil
}
func (c *client) CreateImage(project string, i *compute.Image) error {
	op, err := c.Retry(c.raw.Images.Insert(project, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.globalOperationsWait(project, op.Name); err != nil {
		return err
	}
	var createdImage *compute.Image
	if createdImage, err = c.i.GetImage(project, i.Name); err != nil {
		return err
	}
	*i = *createdImage
	return nil
}
func (c *client) CreateImageBeta(project string, i *computeBeta.Image) error {
	op, err := c.RetryBeta(c.rawBeta.Images.Insert(project, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.globalOperationsWait(project, op.Name); err != nil {
		return err
	}
	var createdImage *computeBeta.Image
	if createdImage, err = c.i.GetImageBeta(project, i.Name); err != nil {
		return err
	}
	*i = *createdImage
	return nil
}
func (c *client) CreateImageAlpha(project string, i *computeAlpha.Image) error {
	op, err := c.RetryAlpha(c.rawAlpha.Images.Insert(project, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.globalOperationsWait(project, op.Name); err != nil {
		return err
	}
	var createdImage *computeAlpha.Image
	if createdImage, err = c.i.GetImageAlpha(project, i.Name); err != nil {
		return err
	}
	*i = *createdImage
	return nil
}
func (c *client) CreateInstance(project, zone string, i *compute.Instance) error {
	op, err := c.Retry(c.raw.Instances.Insert(project, zone, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdInstance *compute.Instance
	if createdInstance, err = c.i.GetInstance(project, zone, i.Name); err != nil {
		return err
	}
	*i = *createdInstance
	return nil
}
func (c *client) CreateInstanceAlpha(project, zone string, i *computeAlpha.Instance) error {
	op, err := c.RetryAlpha(c.rawAlpha.Instances.Insert(project, zone, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdInstance *computeAlpha.Instance
	if createdInstance, err = c.i.GetInstanceAlpha(project, zone, i.Name); err != nil {
		return err
	}
	*i = *createdInstance
	return nil
}
func (c *client) CreateInstanceBeta(project, zone string, i *computeBeta.Instance) error {
	op, err := c.RetryBeta(c.rawBeta.Instances.Insert(project, zone, i).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdInstance *computeBeta.Instance
	if createdInstance, err = c.i.GetInstanceBeta(project, zone, i.Name); err != nil {
		return err
	}
	*i = *createdInstance
	return nil
}
func (c *client) CreateNetwork(project string, n *compute.Network) error {
	op, err := c.Retry(c.raw.Networks.Insert(project, n).Do)
	if err != nil {
		return err
	}
	if err := c.i.globalOperationsWait(project, op.Name); err != nil {
		return err
	}
	var createdNetwork *compute.Network
	if createdNetwork, err = c.i.GetNetwork(project, n.Name); err != nil {
		return err
	}
	*n = *createdNetwork
	return nil
}
func (c *client) CreateSubnetwork(project, region string, n *compute.Subnetwork) error {
	op, err := c.Retry(c.raw.Subnetworks.Insert(project, region, n).Do)
	if err != nil {
		return err
	}
	if err := c.i.regionOperationsWait(project, region, op.Name); err != nil {
		return err
	}
	var createdSubnetwork *compute.Subnetwork
	if createdSubnetwork, err = c.i.GetSubnetwork(project, region, n.Name); err != nil {
		return err
	}
	*n = *createdSubnetwork
	return nil
}
func (c *client) CreateTargetInstance(project, zone string, ti *compute.TargetInstance) error {
	op, err := c.Retry(c.raw.TargetInstances.Insert(project, zone, ti).Do)
	if err != nil {
		return err
	}
	if err := c.i.zoneOperationsWait(project, zone, op.Name); err != nil {
		return err
	}
	var createdTargetInstance *compute.TargetInstance
	if createdTargetInstance, err = c.i.GetTargetInstance(project, zone, ti.Name); err != nil {
		return err
	}
	*ti = *createdTargetInstance
	return nil
}
func (c *client) DeleteFirewallRule(project, name string) error {
	op, err := c.Retry(c.raw.Firewalls.Delete(project, name).Do)
	if err != nil {
		return err
	}
	return c.i.globalOperationsWait(project, op.Name)
}
func (c *client) DeleteImage(project, name string) error {
	op, err := c.Retry(c.raw.Images.Delete(project, name).Do)
	if err != nil {
		return err
	}
	return c.i.globalOperationsWait(project, op.Name)
}
func (c *client) DeleteDisk(project, zone, name string) error {
	op, err := c.Retry(c.raw.Disks.Delete(project, zone, name).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}
func (c *client) SetDiskAutoDelete(project, zone, instance string, autoDelete bool, deviceName string) error {
	op, err := c.Retry(c.raw.Instances.SetDiskAutoDelete(project, zone, instance, autoDelete, deviceName).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}
func (c *client) DeleteForwardingRule(project, region, name string) error {
	op, err := c.Retry(c.raw.ForwardingRules.Delete(project, region, name).Do)
	if err != nil {
		return err
	}
	return c.i.regionOperationsWait(project, region, op.Name)
}
func (c *client) DeleteInstance(project, zone, name string) error {
	op, err := c.Retry(c.raw.Instances.Delete(project, zone, name).Do)
	if err != nil {
		return err
	}
	return c.i.zoneOperationsWait(project, zone, op.Name)
}