def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
forwarding_rule_ref = self.FORWARDING_RULE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
update_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
remove_labels = labels_util.GetRemoveLabelsListFromArgs(args)
if update_labels is None and remove_labels is None:
raise calliope_exceptions.RequiredArgumentException(
'LABELS', 'At least one of --update-labels or '
'--remove-labels must be specified.')
if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules':
forwarding_rule = client.globalForwardingRules.Get(
messages.ComputeGlobalForwardingRulesGetRequest(
**forwarding_rule_ref.AsDict()))
labels_value = messages.GlobalSetLabelsRequest.LabelsValue
else:
forwarding_rule = client.forwardingRules.Get(
messages.ComputeForwardingRulesGetRequest(
**forwarding_rule_ref.AsDict()))
labels_value = messages.RegionSetLabelsRequest.LabelsValue
replacement = labels_util.UpdateLabels(
forwarding_rule.labels,
labels_value,
update_labels=update_labels,
remove_labels=remove_labels)
if not replacement:
return forwarding_rule
if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules':
request = self._CreateGlobalSetLabelsRequest(
messages, forwarding_rule_ref, forwarding_rule, replacement)
operation = client.globalForwardingRules.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(client.globalForwardingRules)
else:
request = self._CreateRegionalSetLabelsRequest(
messages, forwarding_rule_ref, forwarding_rule, replacement)
operation = client.forwardingRules.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.regionOperations')
operation_poller = poller.Poller(client.forwardingRules)
return waiter.WaitFor(operation_poller, operation_ref,
'Updating labels of forwarding rule [{0}]'.format(
forwarding_rule_ref.Name()))
def _Run(self, args, support_user_licenses=False):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
disk_ref = self.DISK_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
disk_info = api_util.GetDiskInfo(disk_ref, client, messages)
service = disk_info.GetService()
if support_user_licenses and args.IsSpecified(
'zone') and _UserLicensesFlagsIncluded(args):
disk_res = messages.Disk(name=disk_ref.Name())
if args.IsSpecified('update_user_licenses'):
disk_res.userLicenses = args.update_user_licenses
disk_update_request = messages.ComputeDisksUpdateRequest(
project=disk_ref.project,
disk=disk_ref.Name(),
diskResource=disk_res,
zone=disk_ref.zone,
paths=['userLicenses'])
update_operation = service.Update(disk_update_request)
update_operation_ref = holder.resources.Parse(
update_operation.selfLink,
collection=disk_info.GetOperationCollection())
update_operation_poller = poller.Poller(service)
result = waiter.WaitFor(
update_operation_poller, update_operation_ref,
'Updating user licenses of disk [{0}]'.format(disk_ref.Name()))
if not _LabelsFlagsIncluded(args):
return result
labels_diff = labels_util.GetAndValidateOpsFromArgs(args)
disk = disk_info.GetDiskResource()
set_label_req = disk_info.GetSetLabelsRequestMessage()
labels_update = labels_diff.Apply(set_label_req.LabelsValue,
disk.labels)
request = disk_info.GetSetDiskLabelsRequestMessage(
disk, labels_update.GetOrNone())
if not labels_update.needs_update:
return disk
operation = service.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection=disk_info.GetOperationCollection())
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args):
"""Issues requests necessary to update Container."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=instances_flags.GetInstanceZoneScopeLister(client))
# fetch the Instance resource
instance = client.apitools_client.instances.Get(
client.messages.ComputeInstancesGetRequest(
**instance_ref.AsDict()))
# find gce-container-declaration metadata entry
for metadata in instance.metadata.items:
if metadata.key == containers_utils.GCE_CONTAINER_DECLARATION:
# update gce-container-declaration
containers_utils.UpdateMetadata(metadata, args)
# update Google Compute Engine resource
operation = client.apitools_client.instances.SetMetadata(
client.messages.ComputeInstancesSetMetadataRequest(
metadata=instance.metadata, **instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(
client.apitools_client.instances)
waiter.WaitFor(
operation_poller, operation_ref,
'Updating specification of container [{0}]'.format(
instance_ref.Name()))
# restart the Virtual Machine
operation = client.apitools_client.instances.Reset(
client.messages.ComputeInstancesResetRequest(
**instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(
client.apitools_client.instances)
return waiter.WaitFor(
operation_poller, operation_ref,
'Restarting container [{0}]'.format(instance_ref.Name()))
raise containers_utils.NoGceContainerDeclarationMetadataKey()
def Run(self, args):
"""Issues the request to delete Signed URL key from the backend bucket."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
api_client = holder.client.apitools_client
messages = holder.client.messages
service = api_client.backendServices
backend_service_ref = flags.GLOBAL_BACKEND_SERVICE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
request = messages.ComputeBackendServicesDeleteSignedUrlKeyRequest(
project=backend_service_ref.project,
backendService=backend_service_ref.Name(),
keyName=args.key_name)
operation = service.DeleteSignedUrlKey(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Deleting Cloud CDN Signed URL key from [{0}]'.format(
backend_service_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
image_ref = self.DISK_IMAGE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
image = client.images.Get(
messages.ComputeImagesGetRequest(**image_ref.AsDict()))
replacement = labels_util.Diff(additions=add_labels).Apply(
messages.GlobalSetLabelsRequest.LabelsValue, image.labels)
if not replacement:
return image
request = messages.ComputeImagesSetLabelsRequest(
project=image_ref.project,
resource=image_ref.image,
globalSetLabelsRequest=messages.GlobalSetLabelsRequest(
labelFingerprint=image.labelFingerprint, labels=replacement))
operation = client.images.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(client.images)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of image [{0}]'.format(image_ref.Name()))
def Run(self, args):
"""Issues the request to add Signed URL key to the backend service."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
api_client = holder.client.apitools_client
messages = holder.client.messages
service = api_client.backendBuckets
backend_bucket_ref = self.BACKEND_BUCKET_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
key_value = files.ReadFileContents(args.key_file).rstrip()
request = messages.ComputeBackendBucketsAddSignedUrlKeyRequest(
project=backend_bucket_ref.project,
backendBucket=backend_bucket_ref.Name(),
signedUrlKey=messages.SignedUrlKey(keyName=args.key_name,
keyValue=key_value))
operation = service.AddSignedUrlKey(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Adding Cloud CDN Signed URL key to [{0}]'.format(
backend_bucket_ref.Name()))
def Run(self, args):
instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs(
args, need_disk_source=True)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
resources = holder.resources
igm_ref = (
instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
ResolveAsResource)(
args,
resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
instance_ref = self._CreateNewInstanceReference(
holder=holder, igm_ref=igm_ref, instance_name=args.instance)
per_instance_config_message = (
instance_configs_messages.CreatePerInstanceConfigMessage)(
holder,
instance_ref,
args.stateful_disk,
args.stateful_metadata,
disk_getter=NonExistentDiskGetter())
operation_ref, service = instance_configs_messages.CallCreateInstances(
holder=holder,
igm_ref=igm_ref,
per_instance_config_message=per_instance_config_message)
operation_poller = poller.Poller(service)
create_result = waiter.WaitFor(operation_poller, operation_ref,
'Creating instance.')
return create_result
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
disk_ref = self.DISK_ARG.ResolveAsResource(
args, holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
update_labels, remove_labels = labels_util.GetAndValidateOpsFromArgs(args)
service = self.GetDisksService(disk_ref, client)
disk = service.Get(self.GetDiskGetRequest(disk_ref, messages))
set_labels_request = self.GetLabelsReplacementRequest(
disk_ref, disk, messages, update_labels, remove_labels)
if not set_labels_request:
return disk
operation = service.SetLabels(set_labels_request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection=self.GetOperationCollection(disk_ref))
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of disk [{0}]'.format(
disk_ref.Name()))
def WaitForOperation(resources, service, operation, backend_service_ref,
message):
"""Waits for the backend service operation to finish.
Args:
resources: The resource parser.
service: apitools.base.py.base_api.BaseApiService, the service representing
the target of the operation.
operation: The operation to wait for.
backend_service_ref: The backend service reference.
message: The message to show.
Returns:
The operation result.
"""
params = {'project': backend_service_ref.project}
if backend_service_ref.Collection() == 'compute.regionBackendServices':
collection = 'compute.regionOperations'
params['region'] = backend_service_ref.region
else:
collection = 'compute.globalOperations'
operation_ref = resources.Parse(operation.name,
params=params,
collection=collection)
operation_poller = poller.Poller(service, backend_service_ref)
return waiter.WaitFor(operation_poller, operation_ref, message)
def Update(self, neg_ref, add_endpoints=None, remove_endpoints=None):
"""Updates a Compute Network Endpoint Group."""
attach_endpoints_ref = None
detach_endpoints_ref = None
if add_endpoints:
operation = self.AttachEndpoints(neg_ref, add_endpoints)
attach_endpoints_ref = self._GetOperationsRef(operation)
if remove_endpoints:
operation = self.DetachEndpoints(neg_ref, remove_endpoints)
detach_endpoints_ref = self._GetOperationsRef(operation)
neg_name = neg_ref.Name()
operation_poller = poller.Poller(self._service)
result = None
result = self._WaitForResult(
operation_poller, attach_endpoints_ref,
'Attaching {0} endpoints to [{1}].'.format(
len(add_endpoints) if add_endpoints else 0, neg_name)) or result
result = self._WaitForResult(
operation_poller, detach_endpoints_ref,
'Detaching {0} endpoints from [{1}].'.format(
len(remove_endpoints) if remove_endpoints else 0, neg_name)
) or result
return result
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
ips_ref = self.IPS_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
ips_info = api_util.GetInPlaceSnapshotInfo(ips_ref, client, messages)
ips = ips_info.GetInPlaceSnapshotResource()
set_label_req = ips_info.GetSetLabelsRequestMessage()
labels_update = labels_util.Diff(additions=add_labels).Apply(
set_label_req.LabelsValue, ips.labels)
request = ips_info.GetSetInPlaceSnapshotLabelsRequestMessage(
ips, labels_update.GetOrNone())
if not labels_update.needs_update:
return ips
service = ips_info.GetService()
operation = service.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection=ips_info.GetOperationCollection())
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of in-place snapshot [{0}]'.format(
ips_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
disk_ref = self.DISK_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
labels_diff = labels_util.GetAndValidateOpsFromArgs(args)
disk_info = api_util.GetDiskInfo(disk_ref, client, messages)
disk = disk_info.GetDiskResource()
set_label_req = disk_info.GetSetLabelsRequestMessage()
labels_update = labels_diff.Apply(set_label_req.LabelsValue,
disk.labels)
request = disk_info.GetSetDiskLabelsRequestMessage(
disk, labels_update.GetOrNone())
if not labels_update.needs_update:
return disk
service = disk_info.GetService()
operation = service.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection=disk_info.GetOperationCollection())
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
snapshot_ref = Update.SnapshotArg.ResolveAsResource(
args, holder.resources)
labels_diff = labels_util.GetAndValidateOpsFromArgs(args)
snapshot = client.snapshots.Get(
messages.ComputeSnapshotsGetRequest(**snapshot_ref.AsDict()))
labels_update = labels_diff.Apply(
messages.GlobalSetLabelsRequest.LabelsValue, snapshot.labels)
if not labels_update.needs_update:
return snapshot
request = messages.ComputeSnapshotsSetLabelsRequest(
project=snapshot_ref.project,
resource=snapshot_ref.snapshot,
globalSetLabelsRequest=messages.GlobalSetLabelsRequest(
labelFingerprint=snapshot.labelFingerprint,
labels=labels_update.labels))
operation = client.snapshots.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(client.snapshots)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of snapshot [{0}]'.format(snapshot_ref.Name()))
def _Patch(self, pdp_ref, resource):
"""Patches a public delegated prefix resource.
Args:
pdp_ref: resource reference.
resource: PublicDelegatedPrefix resource.
Returns:
Operation result from the poller.
"""
# Drop all fields except fingerprint and modifiable ones.
resource = self.messages.PublicDelegatedPrefix(
fingerprint=resource.fingerprint,
publicDelegatedSubPrefixs=resource.publicDelegatedSubPrefixs)
include_fields = []
if not resource.publicDelegatedSubPrefixs:
include_fields.append('publicDelegatedSubPrefixs')
is_regional = hasattr(pdp_ref, 'region')
if is_regional:
request = self.messages.ComputePublicDelegatedPrefixesPatchRequest(
publicDelegatedPrefix=pdp_ref.Name(),
publicDelegatedPrefixResource=resource,
project=pdp_ref.project,
region=pdp_ref.region)
with self.client.apitools_client.IncludeFields(include_fields):
operation = self._regional_service.Patch(request)
operation_ref = self.resources.Parse(
operation.selfLink, collection='compute.regionOperations')
operation_poller = poller.Poller(self._regional_service)
else:
request = self.messages.ComputeGlobalPublicDelegatedPrefixesPatchRequest(
publicDelegatedPrefix=pdp_ref.Name(),
publicDelegatedPrefixResource=resource,
project=pdp_ref.project)
with self.client.apitools_client.IncludeFields(include_fields):
operation = self._global_service.Patch(request)
operation_ref = self.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(self._global_service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating public delegated prefix [{}].'.format(pdp_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
service = holder.client.apitools_client.networks
network_ref = self.NETWORK_ARG.ResolveAsResource(args, holder.resources)
if args.switch_to_custom_subnet_mode:
prompt_msg = 'Network [{0}] will be switched to custom mode. '.format(
network_ref.Name()) + 'This operation cannot be undone.'
console_io.PromptContinue(
message=prompt_msg, default=True, cancel_on_no=True)
result = service.SwitchToCustomMode(
messages.ComputeNetworksSwitchToCustomModeRequest(
project=network_ref.project, network=network_ref.Name()))
operation_ref = resources.REGISTRY.Parse(
result.name,
params={'project': network_ref.project},
collection='compute.globalOperations')
if args.async_:
log.UpdatedResource(
operation_ref,
kind='network {0}'.format(network_ref.Name()),
is_async=True,
details='Run the [gcloud compute operations describe] command '
'to check the status of this operation.')
return result
operation_poller = poller.Poller(service, network_ref)
return waiter.WaitFor(operation_poller, operation_ref,
'Switching network to custom-mode')
network_resource = messages.Network()
should_patch = False
if getattr(args, 'mtu', None) is not None:
network_resource.mtu = args.mtu
should_patch = True
if args.bgp_routing_mode or getattr(args, 'multicast_mode', None):
should_patch = True
if args.bgp_routing_mode:
network_resource.routingConfig = messages.NetworkRoutingConfig()
network_resource.routingConfig.routingMode = (
messages.NetworkRoutingConfig.RoutingModeValueValuesEnum(
args.bgp_routing_mode.upper()))
if getattr(args, 'multicast_mode', None):
network_resource.multicastMode = (
messages.Network.MulticastModeValueValuesEnum(
args.multicast_mode.upper()))
if should_patch:
resource = service.Patch(
messages.ComputeNetworksPatchRequest(
project=network_ref.project,
network=network_ref.Name(),
networkResource=network_resource))
return resource
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
disk_ref = self.DISK_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
if disk_ref.Collection() == 'compute.disks':
service = client.disks
request_type = messages.ComputeDisksGetRequest
elif disk_ref.Collection() == 'compute.regionDisks':
service = client.regionDisks
request_type = messages.ComputeRegionDisksGetRequest
else:
raise ValueError('Unexpected resource argument of {}'.format(
disk_ref.Collection()))
disk = service.Get(request_type(**disk_ref.AsDict()))
if disk_ref.Collection() == 'compute.disks':
operation_collection = 'compute.zoneOperations'
labels_update = labels_util.Diff(additions=add_labels).Apply(
messages.ZoneSetLabelsRequest.LabelsValue, disk.labels)
request = messages.ComputeDisksSetLabelsRequest(
project=disk_ref.project,
resource=disk_ref.disk,
zone=disk_ref.zone,
zoneSetLabelsRequest=messages.ZoneSetLabelsRequest(
labelFingerprint=disk.labelFingerprint,
labels=labels_update.GetOrNone()))
else:
operation_collection = 'compute.regionOperations'
labels_update = labels_util.Diff(additions=add_labels).Apply(
messages.RegionSetLabelsRequest.LabelsValue, disk.labels)
request = messages.ComputeRegionDisksSetLabelsRequest(
project=disk_ref.project,
resource=disk_ref.disk,
region=disk_ref.region,
regionSetLabelsRequest=messages.RegionSetLabelsRequest(
labelFingerprint=disk.labelFingerprint,
labels=labels_update.GetOrNone()))
if not labels_update.needs_update:
return disk
operation = service.SetLabels(request)
operation_ref = holder.resources.Parse(operation.selfLink,
collection=operation_collection)
operation_poller = poller.Poller(service)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args):
"""See base.CreateCommand."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
service = holder.client.apitools_client.routers
router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources)
request_type = messages.ComputeRoutersGetRequest
replacement = service.Get(request_type(**router_ref.AsDict()))
nat = nats_utils.CreateNatMessage(
args,
holder,
with_rules=self.with_rules,
with_tcp_time_wait_timeout=self.with_tcp_time_wait_timeout)
replacement.nats.append(nat)
result = service.Patch(
messages.ComputeRoutersPatchRequest(project=router_ref.project,
region=router_ref.region,
router=router_ref.Name(),
routerResource=replacement))
operation_ref = resources.REGISTRY.Parse(
result.name,
collection='compute.regionOperations',
params={
'project': router_ref.project,
'region': router_ref.region,
})
if args.async_:
log.CreatedResource(
operation_ref,
kind='nat [{0}] in router [{1}]'.format(
nat.name, router_ref.Name()),
is_async=True,
details='Run the [gcloud compute operations describe] command '
'to check the status of this operation.')
return result
target_router_ref = holder.resources.Parse(
router_ref.Name(),
collection='compute.routers',
params={
'project': router_ref.project,
'region': router_ref.region,
})
operation_poller = poller.Poller(service, target_router_ref)
return waiter.WaitFor(
operation_poller, operation_ref,
'Creating NAT [{0}] in router [{1}]'.format(
nat.name, router_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
service = holder.client.apitools_client.routers
router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources)
request_type = messages.ComputeRoutersGetRequest
router = service.Get(request_type(**router_ref.AsDict()))
rule_number = args.rule_number
nat_name = args.nat
nat = nats_utils.FindNatOrRaise(router, nat_name)
rule = rules_utils.FindRuleOrRaise(nat, rule_number)
rules_utils.UpdateRuleMessage(rule,
args,
holder,
nat,
with_private_nat=self.with_private_nat)
result = service.Patch(
messages.ComputeRoutersPatchRequest(project=router_ref.project,
region=router_ref.region,
router=router_ref.Name(),
routerResource=router))
operation_ref = resources.REGISTRY.Parse(
result.name,
collection='compute.regionOperations',
params={
'project': router_ref.project,
'region': router_ref.region,
})
if args.async_:
log.UpdatedResource(
operation_ref,
kind='Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name),
is_async=True,
details='Run the [gcloud compute operations describe] command '
'to check the status of this operation.')
return result
target_router_ref = holder.resources.Parse(
router_ref.Name(),
collection='compute.routers',
params={
'project': router_ref.project,
'region': router_ref.region,
})
operation_poller = poller.Poller(service, target_router_ref)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
resources = holder.resources
igm_ref = (
instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
ResolveAsResource)(
args,
resources,
scope_lister=compute_flags.GetDefaultScopeLister(client),
)
instance_ref = self._CreateInstanceReference(
holder=holder, igm_ref=igm_ref, instance_name=args.instance)
configs_getter = (instance_configs_getter.
InstanceConfigsGetterWithSimpleCache)(client)
configs_getter.check_if_instance_config_exists(
igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True)
per_instance_config = configs_getter.get_instance_config(
igm_ref=igm_ref, instance_ref=instance_ref)
self._ValidateStatefulFlagsForInstanceConfigs(args,
per_instance_config)
per_instance_config_message = self._CombinePerInstanceConfigMessage(
holder, per_instance_config, instance_ref, args)
operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate(
holder=holder,
igm_ref=igm_ref,
per_instance_config_message=per_instance_config_message)
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = holder.client.apitools_client.instanceGroupManagers
elif igm_ref.Collection() == 'compute.regionInstanceGroupManagers':
service = holder.client.apitools_client.regionInstanceGroupManagers
else:
raise ValueError('Unknown reference type {0}'.format(
igm_ref.Collection()))
operation_poller = poller.Poller(service)
update_result = waiter.WaitFor(operation_poller, operation_ref,
'Updating instance config.')
if args.update_instance:
apply_operation_ref = (
instance_configs_messages.CallApplyUpdatesToInstances)(
holder=holder,
igm_ref=igm_ref,
instances=[six.text_type(instance_ref)],
minimal_action=args.instance_update_minimal_action)
return waiter.WaitFor(operation_poller, apply_operation_ref,
'Applying updates to instances.')
return update_result
def Run(self, args):
"""Returns a request for moving a disk."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
target_disk = Move.disk_arg.ResolveAsResource(
args, holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
destination_zone = holder.resources.Parse(
args.destination_zone,
params={
'project': properties.VALUES.core.project.GetOrFail,
},
collection='compute.zones')
client = holder.client.apitools_client
messages = holder.client.messages
request = messages.ComputeProjectsMoveDiskRequest(
diskMoveRequest=messages.DiskMoveRequest(
destinationZone=destination_zone.SelfLink(),
targetDisk=target_disk.SelfLink(),
),
project=target_disk.project,
)
result = client.projects.MoveDisk(request)
operation_ref = resources.REGISTRY.Parse(
result.name,
params={
'project': properties.VALUES.core.project.GetOrFail,
},
collection='compute.globalOperations')
if args.async:
log.UpdatedResource(
operation_ref,
kind='disk {0}'.format(target_disk.Name()),
is_async=True,
details='Run the [gcloud compute operations describe] command '
'to check the status of this operation.'
)
return result
destination_disk_ref = holder.resources.Parse(
target_disk.Name(),
params={
'project': destination_zone.project,
'zone': destination_zone.Name()
},
collection='compute.disks')
operation_poller = poller.Poller(client.disks, destination_disk_ref)
return waiter.WaitFor(
operation_poller, operation_ref,
'Moving disk {0}'.format(target_disk.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(holder.client))
result = None
labels_operation_ref = None
min_cpu_platform_operation_ref = None
deletion_protection_operation_ref = None
shielded_vm_config_ref = None
labels_diff = labels_util.Diff.FromUpdateArgs(args)
if labels_diff.MayHaveUpdates():
instance = client.instances.Get(
messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
result = instance
labels_operation_ref = self._GetLabelsOperationRef(
labels_diff, instance, instance_ref, holder)
if hasattr(args,
'min_cpu_platform') and args.min_cpu_platform is not None:
min_cpu_platform_operation_ref = self._GetMinCpuPlatformOperationRef(
args.min_cpu_platform, instance_ref, holder)
if args.deletion_protection is not None:
deletion_protection_operation_ref = (
self._GetDeletionProtectionOperationRef(
args.deletion_protection, instance_ref, holder))
operation_poller = poller.Poller(client.instances)
result = self._WaitForResult(operation_poller, labels_operation_ref,
'Updating labels of instance [{0}]',
instance_ref.Name()) or result
result = self._WaitForResult(
operation_poller, min_cpu_platform_operation_ref,
'Changing minimum CPU platform of instance [{0}]',
instance_ref.Name()) or result
result = self._WaitForResult(
operation_poller, deletion_protection_operation_ref,
'Setting deletion protection of instance [{0}] to [{1}]',
instance_ref.Name(), args.deletion_protection) or result
if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
if (hasattr(args, 'shielded_vm_secure_boot')
or hasattr(args, 'shielded_vm_vtpm')):
shielded_vm_config_ref = self._GetShieldedVMConfigRef(
instance_ref, args, holder)
result = self._WaitForResult(
operation_poller, shielded_vm_config_ref,
'Setting shieldedVMConfig of instance [{0}]',
instance_ref.Name()) or result
return result
def WaitOperation(self, operation, operation_poller=None, message=None):
if not operation_poller:
operation_poller = poller.Poller(
self._service, self.ref, has_project=self._api_has_project)
if self._op_has_project and 'projects' not in operation.selfLink:
operation.selfLink = operation.selfLink.replace('locations',
'projects/locations')
operation_ref = self._resources.Parse(
operation.selfLink, collection=OP_COLLECTION_NAME)
return waiter.WaitFor(operation_poller, operation_ref, message)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
service = holder.client.apitools_client.routers
router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources)
request_type = messages.ComputeRoutersGetRequest
replacement = service.Get(request_type(**router_ref.AsDict()))
# Retrieve specified NAT and update base fields.
existing_nat = nats_utils.FindNatOrRaise(replacement, args.name)
nat = nats_utils.UpdateNatMessage(existing_nat, args, holder,
self.with_private_nat,
self.with_subnet_all)
request_type = messages.ComputeRoutersPatchRequest
result = service.Patch(
request_type(project=router_ref.project,
region=router_ref.region,
router=router_ref.Name(),
routerResource=replacement))
operation_ref = resources.REGISTRY.Parse(
result.name,
collection='compute.regionOperations',
params={
'project': router_ref.project,
'region': router_ref.region,
})
if args.async_:
log.UpdatedResource(
operation_ref,
kind='nat [{0}] in router [{1}]'.format(
nat.name, router_ref.Name()),
is_async=True,
details='Run the [gcloud compute operations describe] command '
'to check the status of this operation.')
return result
target_router_ref = holder.resources.Parse(
router_ref.Name(),
collection='compute.routers',
params={
'project': router_ref.project,
'region': router_ref.region,
})
operation_poller = poller.Poller(service, target_router_ref)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating nat [{0}] in router [{1}]'.format(
nat.name, router_ref.Name()))
def _StartVm(holder, client, instance_ref):
"""Start the Virtual Machine."""
operation = client.apitools_client.instances.Start(
client.messages.ComputeInstancesStartRequest(**instance_ref.AsDict()))
operation_ref = holder.resources.Parse(operation.selfLink,
collection='compute.zoneOperations')
operation_poller = poller.Poller(client.apitools_client.instances)
return waiter.WaitFor(
operation_poller, operation_ref,
'Starting instance [{0}]'.format(instance_ref.Name()))
def Run(self, args):
instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs(
args, for_update=True)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
resources = holder.resources
igm_ref = (
instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
ResolveAsResource)(
args,
resources,
scope_lister=compute_flags.GetDefaultScopeLister(client),
)
instance_ref = self._CreateInstanceReference(
holder=holder, igm_ref=igm_ref, instance_name=args.instance)
configs_getter = (instance_configs_getter.
InstanceConfigsGetterWithSimpleCache)(client)
configs_getter.check_if_instance_config_exists(
igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True)
per_instance_config_message = self._CombinePerInstanceConfigMessage(
holder, configs_getter, igm_ref, instance_ref,
args.update_stateful_disk, args.remove_stateful_disks,
args.update_stateful_metadata, args.remove_stateful_metadata)
operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate(
holder=holder,
igm_ref=igm_ref,
per_instance_config_message=per_instance_config_message)
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = holder.client.apitools_client.instanceGroupManagers
else:
service = holder.client.apitools_client.regionInstanceGroupManagers
operation_poller = poller.Poller(service)
update_result = waiter.WaitFor(operation_poller, operation_ref,
'Updating instance config.')
if args.force_instance_update:
apply_operation_ref = (
instance_configs_messages.CallApplyUpdatesToInstances)(
holder=holder,
igm_ref=igm_ref,
instances=[str(instance_ref)])
return waiter.WaitFor(operation_poller, apply_operation_ref,
'Applying updates to instances.')
return update_result
def UpdateInstance(holder,
client,
instance_ref,
instance,
args,
container_mount_disk_enabled=False,
container_mount_disk=None):
"""Update an instance and its container metadata."""
operation_poller = poller.Poller(client.apitools_client.instances)
result = _UpdateShieldedInstanceConfig(holder, client, operation_poller,
instance_ref, args)
result = _SetShieldedInstanceIntegrityPolicy(
holder, client, operation_poller, instance_ref, args) or result
# find gce-container-declaration metadata entry
for metadata in instance.metadata.items:
if metadata.key == GCE_CONTAINER_DECLARATION:
UpdateMetadata(
holder,
metadata,
args,
instance,
container_mount_disk_enabled=container_mount_disk_enabled,
container_mount_disk=container_mount_disk)
# update Google Compute Engine resource
operation = client.apitools_client.instances.SetMetadata(
client.messages.ComputeInstancesSetMetadataRequest(
metadata=instance.metadata, **instance_ref.AsDict()))
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
set_metadata_waiter = waiter.WaitFor(
operation_poller, operation_ref,
'Updating specification of container [{0}]'.format(
instance_ref.Name()))
if (instance.status ==
client.messages.Instance.StatusValueValuesEnum.TERMINATED):
return set_metadata_waiter or result
elif (instance.status ==
client.messages.Instance.StatusValueValuesEnum.SUSPENDED):
return _StopVm(holder, client, instance_ref) or result
else:
_StopVm(holder, client, instance_ref)
return _StartVm(holder, client, instance_ref) or result
raise NoGceContainerDeclarationMetadataKey()
def Run(self, args):
"""Issues API requests to update a Target VPN Gateway.
Args:
args: argparse.Namespace, The arguments received by this command.
Returns:
[protorpc.messages.Message], A list of responses returned
by the compute API.
"""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
target_vpn_gateway_ref = self.TARGET_VPN_GATEWAY_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
update_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
remove_labels = labels_util.GetRemoveLabelsListFromArgs(args)
if update_labels is None and remove_labels is None:
raise calliope_exceptions.RequiredArgumentException(
'LABELS', 'At least one of --update-labels or '
'--remove-labels must be specified.')
target_vpn_gateway = client.targetVpnGateways.Get(
messages.ComputeTargetVpnGatewaysGetRequest(
**target_vpn_gateway_ref.AsDict()))
labels_value = messages.RegionSetLabelsRequest.LabelsValue
replacement = labels_util.UpdateLabels(
target_vpn_gateway.labels,
labels_value,
update_labels=update_labels,
remove_labels=remove_labels)
if not replacement:
return target_vpn_gateway
request = self._CreateRegionalSetLabelsRequest(
messages, target_vpn_gateway_ref, target_vpn_gateway, replacement)
operation = client.targetVpnGateways.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.regionOperations')
operation_poller = poller.Poller(client.targetVpnGateways)
return waiter.WaitFor(operation_poller, operation_ref,
'Updating labels of target VPN gateway [{0}]'.format(
target_vpn_gateway_ref.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
target_instance = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(holder.client))
destination_zone = holder.resources.Parse(
args.destination_zone,
params={'project': target_instance.project},
collection='compute.zones')
client = holder.client.apitools_client
messages = holder.client.messages
request = messages.ComputeProjectsMoveInstanceRequest(
instanceMoveRequest=messages.InstanceMoveRequest(
destinationZone=destination_zone.SelfLink(),
targetInstance=target_instance.SelfLink(),
),
project=target_instance.project,
)
result = client.projects.MoveInstance(request)
operation_ref = resources.REGISTRY.Parse(
result.name,
params={'project': target_instance.project},
collection='compute.globalOperations')
if args.async_:
log.UpdatedResource(
operation_ref,
kind='gce instance {0}'.format(target_instance.Name()),
is_async=True,
details='Use [gcloud compute operations describe] command '
'to check the status of this operation.')
return result
destination_instance_ref = holder.resources.Parse(
target_instance.Name(),
collection='compute.instances',
params={
'project': target_instance.project,
'zone': destination_zone.Name()
})
operation_poller = poller.Poller(client.instances,
destination_instance_ref)
return waiter.WaitFor(
operation_poller, operation_ref,
'Moving gce instance {0}'.format(target_instance.Name()))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
instance = client.instances.Get(
messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
for i in instance.networkInterfaces:
if i.name == args.network_interface:
fingerprint = i.fingerprint
break
else:
raise exceptions.UnknownArgumentException(
'network-interface',
'Instance does not have a network interface [{}], '
'present interfaces are [{}].'.format(
args.network_interface,
', '.join([i.name for i in instance.networkInterfaces])))
patch_network_interface = messages.NetworkInterface(
aliasIpRanges=(
alias_ip_range_utils.CreateAliasIpRangeMessagesFromString(
messages, True, args.aliases)),
fingerprint=fingerprint)
request = messages.ComputeInstancesUpdateNetworkInterfaceRequest(
project=instance_ref.project,
instance=instance_ref.instance,
zone=instance_ref.zone,
networkInterface=args.network_interface,
networkInterfaceResource=patch_network_interface)
cleared_fields = []
if not patch_network_interface.aliasIpRanges:
cleared_fields.append('aliasIpRanges')
with client.IncludeFields(cleared_fields):
operation = client.instances.UpdateNetworkInterface(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.zoneOperations')
operation_poller = poller.Poller(client.instances)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating network interface [{0}] of instance [{1}]'.format(
args.network_interface, instance_ref.Name()))
def WaitForOperation(self, ssl_policy_ref, operation_ref, wait_message):
"""Waits for the specified operation to complete and returns the target.
Args:
ssl_policy_ref: The SSL policy reference object.
operation_ref: The operation reference object to wait for.
wait_message: String representing the wait message to display while the
operation is in progress.
Returns:
The resulting resource object after the operation completes.
"""
operation_poller = poller.Poller(self._service, ssl_policy_ref)
return waiter.WaitFor(operation_poller, operation_ref, wait_message)
