def CreateRequests(self, args):
instance_refs = self.CreateZonalReferences(args.instances,
args.zone,
resource_type='instances')
instances = [
self.messages.InstanceReference(instance=instance_ref.SelfLink())
for instance_ref in instance_refs
]
# This check to make sure the regions for the instances are the same is not
# really necessary, but it does allow for a fast fail if the user passes in
# instances from different regions.
unique_regions = set(
utils.ZoneNameToRegionName(instance_ref.zone)
for instance_ref in instance_refs)
if len(unique_regions) > 1:
raise calliope_exceptions.ToolException(
'Instances must all be in the same region as the target pool.')
target_pool_ref = self.CreateRegionalReference(
args.name, unique_regions.pop(), resource_type='targetPools')
request = self.messages.ComputeTargetPoolsRemoveInstanceRequest(
region=target_pool_ref.region,
project=self.project,
targetPool=target_pool_ref.Name(),
targetPoolsRemoveInstanceRequest=(
self.messages.TargetPoolsRemoveInstanceRequest(
instances=instances)))
return [request]
def CreateRequests(self, args):
instance_refs = self.CreateZonalReferences(args.instances,
args.zone,
resource_type='instances')
instances = [
self.messages.InstanceReference(instance=instance_ref.SelfLink())
for instance_ref in instance_refs
]
unique_regions = set(
utils.ZoneNameToRegionName(instance_ref.zone)
for instance_ref in instance_refs)
# Check that all regions are the same.
if len(unique_regions) > 1:
raise calliope_exceptions.ToolException(
'Instances must all be in the same region as the target pool.')
target_pool_ref = self.CreateRegionalReference(
args.name, unique_regions.pop(), resource_type='targetPools')
request = self.messages.ComputeTargetPoolsAddInstanceRequest(
region=target_pool_ref.region,
project=self.project,
targetPool=target_pool_ref.Name(),
targetPoolsAddInstanceRequest=(
self.messages.TargetPoolsAddInstanceRequest(
instances=instances)))
return [request]
def GetRegionalTarget(self, args, forwarding_rule_ref=None):
"""Return the forwarding target for a regionally scoped request."""
if args.target_http_proxy:
raise exceptions.ToolException(
'You cannot specify [--target-http-proxy] for a regional '
'forwarding rule.')
if args.target_instance_zone and not args.target_instance:
raise exceptions.ToolException(
'You cannot specify [--target-instance-zone] unless you are '
'specifying [--target-instance].')
if forwarding_rule_ref:
region_arg = forwarding_rule_ref.region
else:
region_arg = args.region
if args.target_pool:
target_ref = self.CreateRegionalReference(
args.target_pool, region_arg, resource_type='targetPools')
target_region = target_ref.region
elif args.target_instance:
target_ref = self.CreateZonalReference(
args.target_instance, args.target_instance_zone,
resource_type='targetInstances',
flag_names=['--target-instance-zone'],
region_filter=region_arg)
target_region = utils.ZoneNameToRegionName(target_ref.zone)
elif args.target_vpn_gateway:
target_ref = self.CreateRegionalReference(
args.target_vpn_gateway, region_arg,
resource_type='targetVpnGateways')
target_region = target_ref.region
return target_ref, target_region
def CreateRequests(self, args):
self._ValidateArgs(args)
ref = self.CreateZonalReference(args.name, args.zone)
region = utils.ZoneNameToRegionName(ref.zone)
if args.clear_target_pools:
pool_refs = []
else:
pool_refs = self.CreateRegionalReferences(
args.target_pools, region, resource_type='targetPools')
pools = [pool_ref.SelfLink() for pool_ref in pool_refs]
request = (
self.messages.ComputeInstanceGroupManagersSetTargetPoolsRequest(
instanceGroupManager=ref.Name(),
instanceGroupManagersSetTargetPoolsRequest=(
self.messages.InstanceGroupManagersSetTargetPoolsRequest(
targetPools=pools, )),
project=self.project,
zone=ref.zone,
))
return [request]
def CreateNetworkInterfaceMessage(self, args, instance_refs):
"""Returns a new NetworkInterface message."""
network_ref = self.CreateGlobalReference(
args.network, resource_type='networks')
network_interface = self.messages.NetworkInterface(
network=network_ref.SelfLink())
if not args.no_address:
access_config = self.messages.AccessConfig(
name=constants.DEFAULT_ACCESS_CONFIG_NAME,
type=self.messages.AccessConfig.TypeValueValuesEnum.ONE_TO_ONE_NAT)
# If the user provided an external IP, populate the access
# config with it.
if len(instance_refs) == 1:
region = utils.ZoneNameToRegionName(instance_refs[0].zone)
address = self.ExpandAddressFlag(args, region)
if address:
access_config.natIP = address
network_interface.accessConfigs = [access_config]
return network_interface
def CreateRequests(self, args):
"""Creates and returns an instanceGroupManagers.Insert request.
Args:
args: the argparse arguments that this command was invoked with.
Returns:
request: a singleton list containing
ComputeManagedInstanceGroupsInsertRequest message object.
"""
group_ref = self.CreateZonalReference(args.name, args.zone)
self.WarnForZonalCreation([group_ref])
template_ref = self.CreateGlobalReference(
args.template, resource_type='instanceTemplates')
if args.target_pool:
region = utils.ZoneNameToRegionName(group_ref.zone)
pool_refs = self.CreateRegionalReferences(
args.target_pool, region, resource_type='targetPools')
pools = [pool_ref.SelfLink() for pool_ref in pool_refs]
else:
pools = []
instance_group_manager = self.messages.InstanceGroupManager(
name=group_ref.Name(),
zone=group_ref.zone,
baseInstanceName=args.base_instance_name,
description=args.description,
instanceTemplate=template_ref.SelfLink(),
targetPools=pools,
targetSize=int(args.size))
request = self.messages.ComputeInstanceGroupManagersInsertRequest(
instanceGroupManager=instance_group_manager,
project=self.project,
zone=group_ref.zone,
)
return [request]