def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
# Retrieve the specified compute instance.
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
request = client.messages.ComputeInstancesGetRequest(
**instance_ref.AsDict())
instance = client.MakeRequests([(client.apitools_client.instances,
'Get', request)])[0]
# Get JSON Schema for Compute Engine instances (located in
# third_party/py/googlecloudsdk/schemas/...).
schema_path = self.GetSchemaPath(for_help=False)
# Write configuration data to either designated file or stdout.
if args.destination:
with files.FileWriter(args.destination) as stream:
export_util.Export(message=instance,
stream=stream,
schema_path=schema_path)
return log.status.Print('Exported [{}] to \'{}\'.'.format(
instance.name, args.destination))
else:
export_util.Export(message=instance,
stream=sys.stdout,
schema_path=schema_path)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args, holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
request = (client.apitools_client.instances,
'GetSerialPortOutput',
client.messages.ComputeInstancesGetSerialPortOutputRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
port=args.port,
start=args.start,
zone=instance_ref.zone))
errors = []
objects = client.MakeRequests(
requests=[request],
errors_to_collect=errors)
if errors:
raise GetSerialPortOutputException(
'Could not fetch serial port output: ' +
','.join([error[1] for error in errors]))
response = objects[0]
self._start = args.start
self._response = response
return response
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
messages = client.messages
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(client))
maintenance_policy_ref = util.ParseMaintenancePolicy(
holder.resources,
args.resource_maintenance_policies,
project=instance_ref.project,
region=util.GetRegionFromZone(instance_ref.zone))
add_request = messages.ComputeInstancesAddMaintenancePoliciesRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
zone=instance_ref.zone,
instancesAddMaintenancePoliciesRequest=messages.
InstancesAddMaintenancePoliciesRequest(
maintenancePolicies=[maintenance_policy_ref.SelfLink()]))
return client.MakeRequests([(client.apitools_client.instances,
'AddMaintenancePolicies', add_request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
policy = client.MakeRequests([
(client.apitools_client.instances, 'GetIamPolicy',
client.messages.ComputeInstancesGetIamPolicyRequest(
resource=instance_ref.instance,
zone=instance_ref.zone,
project=instance_ref.project))
])[0]
iam_util.RemoveBindingFromIamPolicy(policy, args.member, args.role)
return client.MakeRequests([
(client.apitools_client.instances, 'SetIamPolicy',
client.messages.ComputeInstancesSetIamPolicyRequest(
policy=policy,
project=instance_ref.project,
resource=instance_ref.instance,
zone=instance_ref.zone))
])[0]
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
self._ValidateArgs(args, client)
ref = flags.INSTANCES_ARG_FOR_OS_UPGRADE.ResolveAsResource(
args,
holder.resources,
scope_lister=instances_flags.GetInstanceZoneScopeLister(client))
instance_uri = 'projects/{0}/zones/{1}/instances/{2}'.format(
ref.project, ref.zone, ref.Name())
_PromptForUpgrade(ref, args)
args.zone = ref.zone
log.warning(
'Upgrading OS. This usually takes around 40 minutes but may '
'take up to 90 minutes.')
return daisy_utils.RunOsUpgradeBuild(
args=args,
output_filter=_OUTPUT_FILTER,
instance_uri=instance_uri,
release_track=self.ReleaseTrack().id.lower()
if self.ReleaseTrack() else None)
def Run(self, args):
"""Issues request necessary for setting scheduling options."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
scheduling_options = client.messages.Scheduling()
scheduling_options.automaticRestart = args.restart_on_failure
if args.maintenance_policy:
scheduling_options.onHostMaintenance = (
client.messages.Scheduling.OnHostMaintenanceValueValuesEnum(
args.maintenance_policy))
request = client.messages.ComputeInstancesSetSchedulingRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
scheduling=scheduling_options,
zone=instance_ref.zone)
return client.MakeRequests([(client.apitools_client.instances,
'SetScheduling', request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
messages = client.messages
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(client))
resource_policies = []
for policy in args.resource_policies:
resource_policy_ref = util.ParseResourcePolicyWithZone(
holder.resources,
policy,
project=instance_ref.project,
zone=instance_ref.zone)
resource_policies.append(resource_policy_ref.SelfLink())
add_request = messages.ComputeInstancesAddResourcePoliciesRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
zone=instance_ref.zone,
instancesAddResourcePoliciesRequest=messages.
InstancesAddResourcePoliciesRequest(
resourcePolicies=resource_policies))
return client.MakeRequests([(client.apitools_client.instances,
'AddResourcePolicies', add_request)])
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))
instance = client.apitools_client.instances.Get(
client.messages.ComputeInstancesGetRequest(
**instance_ref.AsDict()))
container_mount_disk = instances_flags.GetValidatedContainerMountDisk(
holder,
args.container_mount_disk,
instance.disks, [],
for_update=True,
client=client.apitools_client)
containers_utils.UpdateInstance(
holder,
client,
instance_ref,
instance,
args,
container_mount_disk_enabled=True,
container_mount_disk=container_mount_disk)
def CreateReference(self, client, resources, args):
flags.ValidatePublicDnsFlags(args)
return flags.INSTANCE_ARG.ResolveAsResource(
args,
resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
policy = client.MakeRequests([
(client.apitools_client.instances, 'GetIamPolicy',
client.messages.ComputeInstancesGetIamPolicyRequest(
resource=instance_ref.instance,
zone=instance_ref.zone,
project=instance_ref.project))
])[0]
iam_util.AddBindingToIamPolicy(client.messages.Binding, policy,
args.member, args.role)
# TODO(b/78371568): Construct the ZoneSetPolicyRequest directly
# out of the parsed policy.
return client.MakeRequests([
(client.apitools_client.instances, 'SetIamPolicy',
client.messages.ComputeInstancesSetIamPolicyRequest(
zoneSetPolicyRequest=client.messages.ZoneSetPolicyRequest(
bindings=policy.bindings, etag=policy.etag),
project=instance_ref.project,
resource=instance_ref.instance,
zone=instance_ref.zone))
])[0]
def Run(self, args):
compute_holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = compute_holder.client
flags.ValidateServiceAccountAndScopeArgs(args)
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
compute_holder.resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=flags.GetInstanceZoneScopeLister(client))
email = self._email(args, instance_ref, client)
scopes = self._scopes(args, instance_ref, client)
if scopes and not email:
raise exceptions.ScopesWithoutServiceAccountException(
'Can not set scopes when there is no service acoount.')
request = client.messages.ComputeInstancesSetServiceAccountRequest(
instancesSetServiceAccountRequest=(
client.messages.InstancesSetServiceAccountRequest(
email=email, scopes=scopes)),
project=instance_ref.project,
zone=instance_ref.zone,
instance=instance_ref.Name())
return client.MakeRequests([(client.apitools_client.instances,
'SetServiceAccount', request)])
def Run(self, args):
"""Issue API requests for route creation, callable from multiple tracks."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
network_uri = self.NETWORK_ARG.ResolveAsResource(
args, holder.resources).SelfLink()
route_ref = self.ROUTE_ARG.ResolveAsResource(args, holder.resources)
if args.next_hop_instance:
next_hop_instance_uri = self.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(
client)).SelfLink()
else:
if args.next_hop_instance_zone:
raise exceptions.ToolException(
'[--next-hop-instance-zone] can only be specified in conjunction '
'with [--next-hop-instance].')
next_hop_instance_uri = None
if args.next_hop_gateway:
next_hop_gateway_ref = flags.NEXT_HOP_GATEWAY_ARG.ResolveAsResource(
args, holder.resources)
next_hop_gateway_uri = next_hop_gateway_ref.SelfLink()
else:
next_hop_gateway_uri = None
next_hop_vpn_tunnel_uri = None
if args.next_hop_vpn_tunnel:
next_hop_vpn_tunnel_uri = self.VPN_TUNNEL_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(
client)).SelfLink()
elif args.next_hop_vpn_tunnel_region:
raise exceptions.ToolException(
'[--next-hop-vpn-tunnel-region] can only be specified in '
'conjunction with [--next-hop-vpn-tunnel].')
request = client.messages.ComputeRoutesInsertRequest(
project=route_ref.project,
route=client.messages.Route(
description=args.description,
destRange=args.destination_range,
name=route_ref.Name(),
network=network_uri,
nextHopInstance=next_hop_instance_uri,
nextHopIp=args.next_hop_address,
nextHopGateway=next_hop_gateway_uri,
nextHopVpnTunnel=next_hop_vpn_tunnel_uri,
priority=args.priority,
tags=args.tags,
))
return client.MakeRequests([(client.apitools_client.routes, 'Insert',
request)])
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 GetInstance(cls, holder, args):
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(holder.client))
request = holder.client.messages.ComputeInstancesGetRequest(
**instance_ref.AsDict())
return holder.client.MakeRequests([
(holder.client.apitools_client.instances, "Get", request)
])[0]
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
csek_key_file = args.csek_key_file
request_list = []
instance_refs = flags.INSTANCES_ARG.ResolveAsResource(
args, holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
if csek_key_file:
instances = self.GetInstances(client, instance_refs)
else:
instances = [None for _ in instance_refs]
for instance_ref, instance in zip(instance_refs, instances):
disks = []
if csek_key_file:
allow_rsa_encrypted = self.ReleaseTrack() in [base.ReleaseTrack.ALPHA,
base.ReleaseTrack.BETA]
csek_keys = csek_utils.CsekKeyStore.FromArgs(args, allow_rsa_encrypted)
for disk in instance.disks:
disk_resource = resources.REGISTRY.Parse(disk.source)
disk_key_or_none = csek_utils.MaybeLookupKeyMessage(
csek_keys, disk_resource, client.apitools_client)
if disk_key_or_none:
disks.append(client.messages.CustomerEncryptionKeyProtectedDisk(
diskEncryptionKey=disk_key_or_none,
source=disk.source))
if disks:
encryption_req = client.messages.InstancesStartWithEncryptionKeyRequest(
disks=disks)
request = (
client.apitools_client.instances,
'StartWithEncryptionKey',
client.messages.ComputeInstancesStartWithEncryptionKeyRequest(
instance=instance_ref.Name(),
instancesStartWithEncryptionKeyRequest=encryption_req,
project=instance_ref.project,
zone=instance_ref.zone))
else:
request = (
client.apitools_client.instances,
'Start',
client.messages.ComputeInstancesStartRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
zone=instance_ref.zone))
request_list.append(request)
return client.MakeRequests(request_list)
def _FetchInstance(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
ssh_helper = ssh_utils.BaseSSHCLIHelper()
instance_ref = flags.SSH_INSTANCE_RESOLVER.ResolveResources(
[args.instance_name],
scope.ScopeEnum.ZONE,
args.zone,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))[0]
return instance_ref, ssh_helper.GetInstance(client, instance_ref)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_refs = flags.INSTANCES_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
requests = []
for instance_ref in instance_refs:
discard_local_ssd = None
if self.ReleaseTrack() != base.ReleaseTrack.GA:
discard_local_ssd = args.discard_local_ssd
requests.append(
(client.apitools_client.instances, 'Suspend',
self._CreateSuspendRequest(client, instance_ref,
discard_local_ssd)))
errors_to_collect = []
responses = client.BatchRequests(requests, errors_to_collect)
if errors_to_collect:
raise exceptions.MultiError(errors_to_collect)
operation_refs = [
holder.resources.Parse(r.selfLink) for r in responses
]
if args.async_:
for operation_ref in operation_refs:
log.status.Print(
'Suspend instance in progress for [{}].'.format(
operation_ref.SelfLink()))
log.status.Print(
'Use [gcloud compute operations describe URI] command to check the '
'status of the operation(s).')
return responses
operation_poller = poller.BatchPoller(client,
client.apitools_client.instances,
instance_refs)
result = waiter.WaitFor(operation_poller,
poller.OperationBatch(operation_refs),
'Suspending instance(s) {0}'.format(', '.join(
i.Name() for i in instance_refs)),
max_wait_ms=None)
for instance_ref in instance_refs:
log.status.Print('Updated [{0}].'.format(instance_ref))
return result
def Run(self, args):
"""Invokes request necessary for adding an access config."""
if self._support_network_tier:
flags.ValidateNetworkTierArgs(args)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
access_config = client.messages.AccessConfig(
name=args.access_config_name,
natIP=args.address,
type=client.messages.AccessConfig.TypeValueValuesEnum.
ONE_TO_ONE_NAT)
if self._support_public_dns:
flags.ValidatePublicDnsFlags(args)
if args.no_public_dns is True:
access_config.setPublicDns = False
elif args.public_dns is True:
access_config.setPublicDns = True
if self._support_public_ptr:
flags.ValidatePublicPtrFlags(args)
if args.no_public_ptr is True:
access_config.setPublicPtr = False
elif args.public_ptr is True:
access_config.setPublicPtr = True
if (args.no_public_ptr_domain is not True
and args.public_ptr_domain is not None):
access_config.publicPtrDomainName = args.public_ptr_domain
network_tier = getattr(args, 'network_tier', None)
if network_tier is not None:
access_config.networkTier = (
client.messages.AccessConfig.NetworkTierValueValuesEnum(
network_tier))
request = client.messages.ComputeInstancesAddAccessConfigRequest(
accessConfig=access_config,
instance=instance_ref.Name(),
networkInterface=args.network_interface,
project=instance_ref.project,
zone=instance_ref.zone)
return client.MakeRequests([(client.apitools_client.instances,
'AddAccessConfig', request)])
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):
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,
support_disk_scope=False,
support_force_attach=False,
support_boot=False):
"""Invokes a request for attaching a disk to an instance."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
disk_ref = self.ParseDiskRef(holder.resources, args, instance_ref,
support_disk_scope)
if args.mode == 'rw':
mode = client.messages.AttachedDisk.ModeValueValuesEnum.READ_WRITE
else:
mode = client.messages.AttachedDisk.ModeValueValuesEnum.READ_ONLY
allow_rsa_encrypted = self.ReleaseTrack() in [
base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA
]
csek_keys = csek_utils.CsekKeyStore.FromArgs(args, allow_rsa_encrypted)
disk_key_or_none = csek_utils.MaybeLookupKeyMessage(
csek_keys, disk_ref, client.apitools_client)
attached_disk = client.messages.AttachedDisk(
deviceName=args.device_name,
mode=mode,
source=disk_ref.SelfLink(),
type=client.messages.AttachedDisk.TypeValueValuesEnum.PERSISTENT,
diskEncryptionKey=disk_key_or_none)
if support_boot and args.boot:
attached_disk.boot = args.boot
request = client.messages.ComputeInstancesAttachDiskRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
attachedDisk=attached_disk,
zone=instance_ref.zone)
if support_force_attach and args.force_attach:
request.forceAttach = args.force_attach
return client.MakeRequests([(client.apitools_client.instances,
'AttachDisk', request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
request = client.messages.ComputeInstancesGetRequest(
**instance_ref.AsDict())
return client.MakeRequests([(client.apitools_client.instances, 'Get',
request)])[0]
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_refs = flags.INSTANCES_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
return client.MakeRequests([
(client.apitools_client.instances, 'Stop',
self._CreateStopRequest(client, instance_ref,
args.discard_local_ssd))
for instance_ref in instance_refs
])
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))
instance = client.apitools_client.instances.Get(
client.messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
containers_utils.UpdateInstance(holder, client, instance_ref, instance,
args)
def _Run(self, args):
"""Issues request necessary for setting scheduling options."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
scheduling_options = client.messages.Scheduling()
scheduling_options.automaticRestart = args.restart_on_failure
if args.IsSpecified('preemptible'):
scheduling_options.preemptible = args.preemptible
cleared_fields = []
if args.IsSpecified('min_node_cpu'):
scheduling_options.minNodeCpus = int(args.min_node_cpu)
elif args.IsSpecified('clear_min_node_cpu'):
scheduling_options.minNodeCpus = None
cleared_fields.append('minNodeCpus')
if args.IsSpecified('maintenance_policy'):
scheduling_options.onHostMaintenance = (
client.messages.Scheduling.OnHostMaintenanceValueValuesEnum(
args.maintenance_policy))
if instance_utils.IsAnySpecified(args, 'node', 'node_affinity_file',
'node_group'):
affinities = sole_tenancy_util.GetSchedulingNodeAffinityListFromArgs(
args, client.messages)
scheduling_options.nodeAffinities = affinities
elif args.IsSpecified('clear_node_affinities'):
scheduling_options.nodeAffinities = []
cleared_fields.append('nodeAffinities')
with holder.client.apitools_client.IncludeFields(cleared_fields):
request = client.messages.ComputeInstancesSetSchedulingRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
scheduling=scheduling_options,
zone=instance_ref.zone)
return client.MakeRequests([(client.apitools_client.instances,
'SetScheduling', request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_refs = flags.INSTANCES_ARG.ResolveAsResource(
args, holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
request_list = []
for instance_ref in instance_refs:
request = client.messages.ComputeInstancesResetRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
zone=instance_ref.zone)
request_list.append((client.apitools_client.instances, 'Reset', request))
return client.MakeRequests(request_list)
def Run(self, args):
"""See base.UpdateCommand."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
instance_ref = None
if args.instance is not None:
instance_ref = self.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(
holder.client))
return self._Run(args,
support_bfd=True,
support_enable=True,
support_bfd_mode=True,
instance_ref=instance_ref)
def _ResolveInstance(self, args):
"""Resolves the arguments into an instance.
Args:
args: The command line arguments.
Returns:
An instance reference to a VM.
"""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
compute_client = holder.client
resources = holder.resources
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args,
resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(compute_client))
return instance_ref
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))
update_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
remove_labels = labels_util.GetRemoveLabelsListFromArgs(args)
result = None
labels_operation_ref = None
min_cpu_platform_operation_ref = None
deletion_protection_operation_ref = None
if update_labels or remove_labels:
instance = client.instances.Get(
messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
result = instance
labels_operation_ref = self._GetLabelsOperationRef(
update_labels, remove_labels, 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)
deletion_protection = getattr(args, 'deletion_protection', None)
if 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(), deletion_protection) or result
return result
def _GetHostKeyFromInstance(self, zone, ssh_helper, instance):
"""Wrapper around SSH Utils to get the host keys for SSH."""
instance_ref = instance_flags.SSH_INSTANCE_RESOLVER.ResolveResources(
[instance.name], compute_scope.ScopeEnum.ZONE, zone,
self.resources,
scope_lister=instance_flags.GetInstanceZoneScopeLister(self.client))[0]
project = ssh_helper.GetProject(self.client, instance_ref.project)
host_keys = ssh_helper.GetHostKeysFromGuestAttributes(
self.client, instance_ref, instance, project)
if host_keys is not None and not host_keys:
# Only display this message if there was an attempt to retrieve
# host keys but it was unsuccessful(yielded empty dict). If Guest
# Attributes is disabled, there is no attempt to retrieve host keys.
log.status.Print('Unable to retrieve host keys from instance metadata. '
'Continuing.')
return host_keys
