def _CreateGlobalRequests(self, client, resources, args, forwarding_rule_ref): """Create a globally scoped request.""" ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) port_range = _ResolvePortRange(args.port_range, range_list) if ports_all_specified: raise exceptions.ToolException( '[--ports] can not be specified to all for global forwarding rules.' ) if not port_range: raise exceptions.ToolException( '[--ports] is required for global forwarding rules.') target_ref = utils.GetGlobalTarget(resources, args) protocol = self.ConstructProtocol(client.messages, args) if args.address is None or args.ip_version: ip_version = client.messages.ForwardingRule.IpVersionValueValuesEnum( args.ip_version or 'IPV4') else: ip_version = None address = self._ResolveAddress( resources, args, compute_flags.compute_scope.ScopeEnum.GLOBAL, forwarding_rule_ref) forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, portRange=port_range, target=target_ref.SelfLink(), ipVersion=ip_version, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=_GetLoadBalancingScheme(args, client.messages)) if args.IsSpecified('network'): forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing).ResolveAsResource( args, resources).SelfLink() if self._support_global_access and args.IsSpecified( 'allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access request = client.messages.ComputeGlobalForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project) return [(client.apitools_client.globalForwardingRules, 'Insert', request)]
def _CreateRegionalRequests(self, client, resources, args, forwarding_rule_ref): """Create a regionally scoped request.""" target_ref, region_ref = utils.GetRegionalTarget( client, resources, args, forwarding_rule_ref, include_l7_internal_load_balancing=self. _support_l7_internal_load_balancing) if not args.region and region_ref: args.region = region_ref protocol = self.ConstructProtocol(client.messages, args) address = self._ResolveAddress( resources, args, compute_flags.compute_scope.ScopeEnum.REGION, forwarding_rule_ref) forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=_GetLoadBalancingScheme(args, client.messages)) ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) if (target_ref.Collection() == 'compute.regionBackendServices') or ( target_ref.Collection() == 'compute.targetInstances' and args.load_balancing_scheme == 'INTERNAL'): forwarding_rule.portRange = (six.text_type(args.port_range) if args.port_range else None) if target_ref.Collection() == 'compute.regionBackendServices': forwarding_rule.backendService = target_ref.SelfLink() else: forwarding_rule.target = target_ref.SelfLink() if ports_all_specified: forwarding_rule.allPorts = True if range_list: forwarding_rule.portRange = None forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() elif ( (target_ref.Collection() == 'compute.regionTargetHttpProxies' or target_ref.Collection() == 'compute.regionTargetHttpsProxies') and args.load_balancing_scheme == 'INTERNAL'): forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() forwarding_rule.target = target_ref.SelfLink() elif args.load_balancing_scheme == 'INTERNAL': raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'Only target instances and backend services should be specified as ' 'a target for internal load balancing.') elif args.load_balancing_scheme == 'INTERNAL_MANAGED': forwarding_rule.portRange = (_ResolvePortRange( args.port_range, range_list)) if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() forwarding_rule.target = target_ref.SelfLink() else: forwarding_rule.portRange = (_ResolvePortRange( args.port_range, range_list)) forwarding_rule.target = target_ref.SelfLink() if hasattr(args, 'service_label'): forwarding_rule.serviceLabel = args.service_label if self._support_global_access and args.IsSpecified( 'allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access if hasattr(args, 'is_mirroring_collector'): forwarding_rule.isMirroringCollector = args.is_mirroring_collector request = client.messages.ComputeForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project, region=forwarding_rule_ref.region) return [(client.apitools_client.forwardingRules, 'Insert', request)]
def _CreateRegionalRequests(self, client, resources, args, forwarding_rule_ref): """Create a regionally scoped request.""" is_psc_ilb = False if hasattr(args, 'target_service_attachment' ) and args.target_service_attachment: if not self._support_target_service_attachment: raise exceptions.InvalidArgumentException( '--target-service-attachment', 'Private Service Connect for ILB (the target-service-attachment ' 'option) is not supported in this API version.') else: is_psc_ilb = True target_ref, region_ref = utils.GetRegionalTarget( client, resources, args, forwarding_rule_ref, include_l7_internal_load_balancing=self. _support_l7_internal_load_balancing, include_target_service_attachment=self. _support_target_service_attachment) if not args.region and region_ref: args.region = region_ref protocol = self.ConstructProtocol(client.messages, args) address = self._ResolveAddress( resources, args, compute_flags.compute_scope.ScopeEnum.REGION, forwarding_rule_ref) load_balancing_scheme = _GetLoadBalancingScheme( args, client.messages, is_psc_ilb) if is_psc_ilb and load_balancing_scheme: raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'The --load-balancing-scheme flag is not allowed for PSC-ILB ' 'forwarding rules.') if args.ip_version: ip_version = client.messages.ForwardingRule.IpVersionValueValuesEnum( args.ip_version) else: ip_version = None forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=load_balancing_scheme) if ip_version: forwarding_rule.ipVersion = ip_version ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) if target_ref.Collection() == 'compute.serviceAttachments': forwarding_rule.target = target_ref.SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() elif (target_ref.Collection() == 'compute.regionBackendServices') or ( target_ref.Collection() == 'compute.targetInstances' and args.load_balancing_scheme == 'INTERNAL'): forwarding_rule.portRange = (six.text_type(args.port_range) if args.port_range else None) if target_ref.Collection() == 'compute.regionBackendServices': forwarding_rule.backendService = target_ref.SelfLink() else: forwarding_rule.target = target_ref.SelfLink() if ports_all_specified: forwarding_rule.allPorts = True if range_list: forwarding_rule.portRange = None forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() elif ( (target_ref.Collection() == 'compute.regionTargetHttpProxies' or target_ref.Collection() == 'compute.regionTargetHttpsProxies') and args.load_balancing_scheme == 'INTERNAL'): forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() forwarding_rule.target = target_ref.SelfLink() elif args.load_balancing_scheme == 'INTERNAL': raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'Only target instances and backend services should be specified as ' 'a target for internal load balancing.') elif args.load_balancing_scheme == 'INTERNAL_MANAGED': forwarding_rule.portRange = (_ResolvePortRange( args.port_range, range_list)) if args.subnet is not None: if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing ).ResolveAsResource(args, resources).SelfLink() forwarding_rule.target = target_ref.SelfLink() else: forwarding_rule.portRange = (_ResolvePortRange( args.port_range, range_list)) forwarding_rule.target = target_ref.SelfLink() if hasattr(args, 'service_label'): forwarding_rule.serviceLabel = args.service_label if self._support_global_access and args.IsSpecified( 'allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access if hasattr(args, 'is_mirroring_collector'): forwarding_rule.isMirroringCollector = args.is_mirroring_collector if hasattr(args, 'service_directory_registration' ) and args.service_directory_registration: # Parse projects/../locations/../namespaces/../services/.. match = re.match( r'^projects/([^/]+)/locations/([^/]+)/namespaces/([^/]+)/services/([^/]+)$', args.service_directory_registration) if not match: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Must be of the form projects/PROJECT/locations/REGION/namespace/NAMESPACE/services/SERVICE' ) project = match.group(1) region = match.group(2) if project != forwarding_rule_ref.project or region != forwarding_rule_ref.region: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Service Directory registration must be in the same project and region as the forwarding rule.' ) sd_registration = client.messages.ForwardingRuleServiceDirectoryRegistration( namespace=match.group(3), service=match.group(4)) forwarding_rule.serviceDirectoryRegistrations.append( sd_registration) request = client.messages.ComputeForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project, region=forwarding_rule_ref.region) return [(client.apitools_client.forwardingRules, 'Insert', request)]
def _CreateGlobalRequests(self, client, resources, args, forwarding_rule_ref): """Create a globally scoped request.""" if hasattr(args, 'service_directory_registration' ) and args.service_directory_registration: raise exceptions.InvalidArgumentException( '--service-directory-registration', '[--service-directory-registration] can not be specified for global forwarding rules.' ) is_psc_google_apis = False if hasattr(args, 'target_google_apis_bundle' ) and args.target_google_apis_bundle: if not self._support_psc_google_apis: raise exceptions.InvalidArgumentException( '--target-google-apis-bundle', 'Private Service Connect for Google APIs (the target-google-apis-bundle option ' 'for forwarding rules) is not supported in this API version.' ) else: is_psc_google_apis = True ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) port_range = _ResolvePortRange(args.port_range, range_list) load_balancing_scheme = _GetLoadBalancingScheme( args, client.messages, is_psc_google_apis) if ports_all_specified and not is_psc_google_apis: raise exceptions.InvalidArgumentException( '--ports', '[--ports] can not be specified to all for global forwarding rules.' ) if not is_psc_google_apis and not port_range: raise exceptions.InvalidArgumentException( '--ports', '[--ports] is required for global forwarding rules.') if is_psc_google_apis: rule_name = forwarding_rule_ref.Name() if len(rule_name) > 20 or rule_name[0].isdigit( ) or not rule_name.isalnum(): raise exceptions.ToolException( 'A forwarding rule to Google APIs must have a name that is between ' ' 1-20 characters long, alphanumeric, starting with a letter.' ) if port_range: raise exceptions.InvalidArgumentException( '--ports', '[--ports] is not allowed for PSC-GoogleApis forwarding rules.' ) if load_balancing_scheme: raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'The --load-balancing-scheme flag is not allowed for PSC-GoogleApis' ' forwarding rules.') if args.target_google_apis_bundle in flags.PSC_GOOGLE_APIS_BUNDLES: target_as_str = args.target_google_apis_bundle else: bundles_list = ', '.join(flags.PSC_GOOGLE_APIS_BUNDLES) raise exceptions.InvalidArgumentException( '--target-google-apis-bundle', 'The valid values for target-google-apis-bundle are: ' + bundles_list) else: target_ref = utils.GetGlobalTarget(resources, args) target_as_str = target_ref.SelfLink() protocol = self.ConstructProtocol(client.messages, args) if args.address is None or args.ip_version: ip_version = client.messages.ForwardingRule.IpVersionValueValuesEnum( args.ip_version or 'IPV4') else: ip_version = None address = self._ResolveAddress( resources, args, compute_flags.compute_scope.ScopeEnum.GLOBAL, forwarding_rule_ref) forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, portRange=port_range, target=target_as_str, ipVersion=ip_version, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=load_balancing_scheme) if args.IsSpecified('network'): forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing).ResolveAsResource( args, resources).SelfLink() if self._support_global_access and args.IsSpecified( 'allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access request = client.messages.ComputeGlobalForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project) return [(client.apitools_client.globalForwardingRules, 'Insert', request)]
def _CreateRegionalRequests(self, client, resources, args, forwarding_rule_ref): """Create a regionally scoped request.""" is_psc_ilb = False if hasattr(args, 'target_service_attachment') and args.target_service_attachment: if not self._support_target_service_attachment: raise exceptions.InvalidArgumentException( '--target-service-attachment', 'Private Service Connect for ILB (the target-service-attachment ' 'option) is not supported in this API version.') else: is_psc_ilb = True target_ref, region_ref = utils.GetRegionalTarget( client, resources, args, forwarding_rule_ref, include_regional_tcp_proxy=self._support_regional_tcp_proxy, include_l7_internal_load_balancing=self ._support_l7_internal_load_balancing, include_target_service_attachment=self ._support_target_service_attachment) if not args.region and region_ref: args.region = region_ref protocol = self.ConstructProtocol(client.messages, args) address = self._ResolveAddress(resources, args, compute_flags.compute_scope.ScopeEnum.REGION, forwarding_rule_ref) load_balancing_scheme = _GetLoadBalancingScheme(args, client.messages, is_psc_ilb) if is_psc_ilb and load_balancing_scheme: raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'The --load-balancing-scheme flag is not allowed for PSC-ILB ' 'forwarding rules.') if args.ip_version: ip_version = client.messages.ForwardingRule.IpVersionValueValuesEnum( args.ip_version) else: ip_version = None forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=load_balancing_scheme) if ip_version: forwarding_rule.ipVersion = ip_version if self._support_source_ip_range and args.source_ip_ranges: forwarding_rule.sourceIpRanges = args.source_ip_ranges if args.subnet is not None: # Subnet arg needed for: # - L4ILB and internal protocol forwarding (scheme INTERNAL, target BES # or target instance) # - L7ILB (scheme INTERNAL_MANAGED) # - NetLB or external protocol forwarding when using IPv6 (scheme # EXTERNAL target BES or target instance) if not args.subnet_region: args.subnet_region = forwarding_rule_ref.region forwarding_rule.subnetwork = flags.SUBNET_ARG.ResolveAsResource( args, resources).SelfLink() if args.network is not None: # Network arg needed for: # - L4ILB and internal protocol forwarding (scheme INTERNAL, target BES # or target instance) # - L7ILB (scheme INTERNAL_MANAGED) # - PSC forwarding rules (no scheme) forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing).ResolveAsResource( args, resources).SelfLink() ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) if target_ref.Collection() == 'compute.regionBackendServices': # A FR pointing to a BES has no target attribute. forwarding_rule.backendService = target_ref.SelfLink() forwarding_rule.target = None else: # A FR pointing to anything not a BES has a target attribute. forwarding_rule.backendService = None forwarding_rule.target = target_ref.SelfLink() if ((target_ref.Collection() == 'compute.regionBackendServices' or target_ref.Collection() == 'compute.targetInstances') and args.load_balancing_scheme == 'INTERNAL'): # This is for L4ILB and internal protocol forwarding. # API fields allPorts, ports, and portRange are mutually exclusive. # API field portRange is not valid for this case. # Use of L3_DEFAULT implies all ports even if allPorts is unset. if ports_all_specified: forwarding_rule.allPorts = True elif range_list: forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] elif ((target_ref.Collection() == 'compute.regionTargetHttpProxies' or target_ref.Collection() == 'compute.regionTargetHttpsProxies') and args.load_balancing_scheme == 'INTERNAL'): # This is a legacy configuration for L7ILB. forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] elif args.load_balancing_scheme == 'INTERNAL': # There are currently no other valid combinations of targets with scheme # internal. With scheme internal, targets must presently be a regional # backend service (L4ILB) or a target instance (protocol forwarding). raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'Only target instances and backend services should be specified as ' 'a target for internal load balancing.') elif args.load_balancing_scheme == 'INTERNAL_MANAGED': # This is L7ILB. forwarding_rule.portRange = _MakeSingleUnifiedPortRange( args.port_range, range_list) elif args.load_balancing_scheme == 'EXTERNAL_MANAGED': # This is regional L7XLB. forwarding_rule.portRange = _MakeSingleUnifiedPortRange( args.port_range, range_list) elif ((target_ref.Collection() == 'compute.regionBackendServices') and ((args.load_balancing_scheme == 'EXTERNAL') or (not args.load_balancing_scheme))): # This is NetLB using a backend service. Scheme is either explicitly # EXTERNAL or not supplied (EXTERNAL is the default scheme). # API fields allPorts, ports, and portRange are mutually exclusive. # All three API fields are valid for this case. # Use of L3_DEFAULT implies all ports even if allPorts is unset. if ports_all_specified: forwarding_rule.allPorts = True elif range_list: if len(range_list) > 1: # More than one port, potentially discontiguous, from --ports= flag. forwarding_rule.ports = [ six.text_type(p) for p in _GetPortList(range_list) ] else: # Exactly one value from --ports= flag. Might be a single port (80); # might be a range (80-90). Since it might be a range, the portRange # API attribute is more appropriate. forwarding_rule.portRange = six.text_type(range_list[0]) elif args.port_range: forwarding_rule.portRange = _MakeSingleUnifiedPortRange( args.port_range, range_list) elif ((target_ref.Collection() == 'compute.targetPool' or target_ref.Collection() == 'compute.targetInstances') and ((args.load_balancing_scheme == 'EXTERNAL') or (not args.load_balancing_scheme))): # This is NetLB using a target pool or external protocol forwarding. # Scheme is either explicitly EXTERNAL or not supplied (EXTERNAL is the # default scheme). # API fields allPorts, ports, and portRange are mutually exclusive. # API field ports is not valid for this case. # Use of L3_DEFAULT implies all ports by definition. if ports_all_specified: forwarding_rule.allPorts = True else: forwarding_rule.portRange = _MakeSingleUnifiedPortRange( args.port_range, range_list) else: # All other regional forwarding rules with load balancing scheme EXTERNAL. forwarding_rule.portRange = _MakeSingleUnifiedPortRange( args.port_range, range_list) if hasattr(args, 'service_label'): forwarding_rule.serviceLabel = args.service_label if self._support_global_access and args.IsSpecified('allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access if self._support_psc_global_access and args.IsSpecified( 'allow_psc_global_access'): forwarding_rule.allowPscGlobalAccess = args.allow_psc_global_access if self._support_disable_automate_dns_zone and args.IsSpecified( 'disable_automate_dns_zone'): forwarding_rule.noAutomateDnsZone = args.disable_automate_dns_zone if hasattr(args, 'is_mirroring_collector'): forwarding_rule.isMirroringCollector = args.is_mirroring_collector if hasattr(args, 'service_directory_registration' ) and args.service_directory_registration: if is_psc_ilb: # Parse projects/../locations/../namespaces/.. match = re.match( r'^projects/([^/]+)/locations/([^/]+)/namespaces/([^/]+)$', args.service_directory_registration) if not match: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'If set, must be of the form projects/PROJECT/locations/REGION/namespaces/NAMESPACE' ) project = match.group(1) region = match.group(2) if project != forwarding_rule_ref.project or region != forwarding_rule_ref.region: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Service Directory registration must be in the same project and region as the forwarding rule.' ) sd_registration = client.messages.ForwardingRuleServiceDirectoryRegistration( namespace=match.group(3)) forwarding_rule.serviceDirectoryRegistrations.append(sd_registration) else: if not self._support_sd_registration_for_regional: raise exceptions.InvalidArgumentException( '--service-directory-registration', """flag is available in one or more alternate release tracks. Try: gcloud alpha compute forwarding-rules create --service-directory-registration gcloud beta compute forwarding-rules create --service-directory-registration""" ) # Parse projects/../locations/../namespaces/../services/.. match = re.match( r'^projects/([^/]+)/locations/([^/]+)/namespaces/([^/]+)/services/([^/]+)$', args.service_directory_registration) if not match: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Must be of the form projects/PROJECT/locations/REGION/namespaces/NAMESPACE/services/SERVICE' ) project = match.group(1) region = match.group(2) if project != forwarding_rule_ref.project or region != forwarding_rule_ref.region: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Service Directory registration must be in the same project and region as the forwarding rule.' ) sd_registration = client.messages.ForwardingRuleServiceDirectoryRegistration( namespace=match.group(3), service=match.group(4)) forwarding_rule.serviceDirectoryRegistrations.append(sd_registration) request = client.messages.ComputeForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project, region=forwarding_rule_ref.region) return [(client.apitools_client.forwardingRules, 'Insert', request)]
def _CreateGlobalRequests(self, client, resources, args, forwarding_rule_ref): """Create a globally scoped request.""" is_psc_google_apis = False if hasattr(args, 'target_google_apis_bundle') and args.target_google_apis_bundle: if not self._support_psc_google_apis: raise exceptions.InvalidArgumentException( '--target-google-apis-bundle', 'Private Service Connect for Google APIs (the target-google-apis-bundle option ' 'for forwarding rules) is not supported in this API version.') else: is_psc_google_apis = True sd_registration = None if hasattr(args, 'service_directory_registration' ) and args.service_directory_registration: if not is_psc_google_apis: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Can only be specified for regional forwarding rules or Private Service Connect forwarding rules targeting a Google APIs bundle.' ) # Parse projects/../locations/.. match = re.match( r'^projects/([^/]+)/locations/([^/]+)(?:/namespaces/([^/]+))?$', args.service_directory_registration) if not match: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Must be of the form projects/PROJECT/locations/REGION or projects/PROJECT/locations/REGION/namespaces/NAMESPACE' ) project = match.group(1) region = match.group(2) namespace = match.group(3) if project != forwarding_rule_ref.project: raise exceptions.InvalidArgumentException( '--service-directory-registration', 'Must be in the same project as the forwarding rule.') sd_registration = client.messages.ForwardingRuleServiceDirectoryRegistration( serviceDirectoryRegion=region, namespace=namespace) ports_all_specified, range_list = _ExtractPortsAndAll(args.ports) port_range = _MakeSingleUnifiedPortRange(args.port_range, range_list) # All global forwarding rules must use EXTERNAL or INTERNAL_SELF_MANAGED # schemes presently. load_balancing_scheme = _GetLoadBalancingScheme(args, client.messages, is_psc_google_apis) if is_psc_google_apis: rule_name = forwarding_rule_ref.Name() if len(rule_name) > 20 or rule_name[0].isdigit( ) or not rule_name.isalnum(): raise fw_exceptions.ArgumentError( 'A forwarding rule to Google APIs must have a name that is between ' ' 1-20 characters long, alphanumeric, starting with a letter.') if port_range: raise exceptions.InvalidArgumentException( '--ports', '[--ports] is not allowed for PSC-GoogleApis forwarding rules.') if load_balancing_scheme: raise exceptions.InvalidArgumentException( '--load-balancing-scheme', 'The --load-balancing-scheme flag is not allowed for PSC-GoogleApis' ' forwarding rules.') if args.target_google_apis_bundle in flags.PSC_GOOGLE_APIS_BUNDLES: target_as_str = args.target_google_apis_bundle else: bundles_list = ', '.join(flags.PSC_GOOGLE_APIS_BUNDLES) raise exceptions.InvalidArgumentException( '--target-google-apis-bundle', 'The valid values for target-google-apis-bundle are: ' + bundles_list) else: # L7XLB in Premium Tier. target_ref = utils.GetGlobalTarget(resources, args) target_as_str = target_ref.SelfLink() if ports_all_specified: raise exceptions.InvalidArgumentException( '--ports', '[--ports] cannot be set to ALL for global forwarding rules.') if not port_range: raise exceptions.InvalidArgumentException( '--ports', '[--ports] is required for global forwarding rules.') protocol = self.ConstructProtocol(client.messages, args) if args.address is None or args.ip_version: ip_version = client.messages.ForwardingRule.IpVersionValueValuesEnum( args.ip_version or 'IPV4') else: ip_version = None address = self._ResolveAddress(resources, args, compute_flags.compute_scope.ScopeEnum.GLOBAL, forwarding_rule_ref) forwarding_rule = client.messages.ForwardingRule( description=args.description, name=forwarding_rule_ref.Name(), IPAddress=address, IPProtocol=protocol, portRange=port_range, target=target_as_str, ipVersion=ip_version, networkTier=_ConstructNetworkTier(client.messages, args), loadBalancingScheme=load_balancing_scheme) if sd_registration: forwarding_rule.serviceDirectoryRegistrations.append(sd_registration) if args.IsSpecified('network'): forwarding_rule.network = flags.NetworkArg( self._support_l7_internal_load_balancing).ResolveAsResource( args, resources).SelfLink() if self._support_global_access and args.IsSpecified('allow_global_access'): forwarding_rule.allowGlobalAccess = args.allow_global_access request = client.messages.ComputeGlobalForwardingRulesInsertRequest( forwardingRule=forwarding_rule, project=forwarding_rule_ref.project) return [(client.apitools_client.globalForwardingRules, 'Insert', request)]