def _UpdateBgpPeerMessage(messages,
router_message,
args,
support_bfd=False,
support_enable=False):
"""Updates base attributes of a BGP peer based on flag arguments."""
peer = router_utils.FindBgpPeerOrRaise(router_message, args.peer_name)
attrs = {
'interfaceName': args.interface,
'ipAddress': args.ip_address,
'peerIpAddress': args.peer_ip_address,
'peerAsn': args.peer_asn,
'advertisedRoutePriority': args.advertised_route_priority,
}
if support_enable and args.enabled is not None:
if args.enabled:
attrs['enable'] = messages.RouterBgpPeer.EnableValueValuesEnum.TRUE
else:
attrs[
'enable'] = messages.RouterBgpPeer.EnableValueValuesEnum.FALSE
for attr, value in attrs.items():
if value is not None:
setattr(peer, attr, value)
if support_bfd:
bfd = None
bfd = _UpdateBgpPeerBfdMessage(messages, peer, args)
if bfd is not None:
setattr(peer, 'bfd', bfd)
return peer
def testFindBgpPeerOrRaise(self):
router = self.messages.Router()
router.bgpPeers.append(
self.messages.RouterBgpPeer(name='my-peer',
interfaceName='a',
peerAsn=65002,
ipAddress='1.1.1.1',
peerIpAddress='1.1.1.2',
advertisedRoutePriority=1))
peer = router_utils.FindBgpPeerOrRaise(router, 'my-peer')
self.assertEqual(peer, router.bgpPeers[0])
error_msg = 'peer `nonexistent-peer` not found'
with self.AssertRaisesExceptionMatches(router_utils.PeerNotFoundError,
error_msg):
router_utils.FindBgpPeerOrRaise(router, 'nonexistent-peer')
def _UpdateBgpPeerMessage(router_message, args):
"""Updates base attributes of a BGP peer based on flag arguments."""
peer = router_utils.FindBgpPeerOrRaise(router_message, args.peer_name)
attrs = {
'interfaceName': args.interface,
'ipAddress': args.ip_address,
'peerIpAddress': args.peer_ip_address,
'peerAsn': args.peer_asn,
'advertisedRoutePriority': args.advertised_route_priority,
}
for attr, value in attrs.items():
if value is not None:
setattr(peer, attr, value)
return peer
def _Run(self,
args,
support_bfd_mode=False,
support_md5_authentication_keys=False):
# Manually ensure replace/incremental flags are mutually exclusive.
router_utils.CheckIncompatibleFlagsOrRaise(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 peer and update base fields.
peer = router_utils.FindBgpPeerOrRaise(replacement, args.peer_name)
md5_authentication_key_name = None
cleared_fields = []
if support_md5_authentication_keys:
if args.clear_md5_authentication_key and peer.md5AuthenticationKeyName is not None:
replacement.md5AuthenticationKeys = [
md5_authentication_key for md5_authentication_key in
replacement.md5AuthenticationKeys
if md5_authentication_key.name !=
peer.md5AuthenticationKeyName
]
if not replacement.md5AuthenticationKeys:
cleared_fields.append('md5AuthenticationKeys')
elif args.md5_authentication_key is not None:
if peer.md5AuthenticationKeyName is not None:
md5_authentication_key_name = peer.md5AuthenticationKeyName
for md5_authentication_key in replacement.md5AuthenticationKeys:
if md5_authentication_key.name == md5_authentication_key_name:
md5_authentication_key.key = args.md5_authentication_key
break
else:
md5_authentication_key_name = router_utils.GenerateMd5AuthenticationKeyName(
replacement, args)
md5_authentication_key = messages.RouterMd5AuthenticationKey(
name=md5_authentication_key_name,
key=args.md5_authentication_key)
replacement.md5AuthenticationKeys.append(
md5_authentication_key)
_UpdateBgpPeerMessage(
peer,
messages,
args,
md5_authentication_key_name=md5_authentication_key_name,
support_bfd_mode=support_bfd_mode,
support_md5_authentication_keys=support_md5_authentication_keys)
if router_utils.HasReplaceAdvertisementFlags(args):
mode, groups, ranges = router_utils.ParseAdvertisements(
messages=messages,
resource_class=messages.RouterBgpPeer,
args=args)
router_utils.PromptIfSwitchToDefaultMode(
messages=messages,
resource_class=messages.RouterBgpPeer,
existing_mode=peer.advertiseMode,
new_mode=mode)
attrs = {
'advertiseMode': mode,
'advertisedGroups': groups,
'advertisedIpRanges': ranges,
}
for attr, value in attrs.items():
if value is not None:
setattr(peer, attr, value)
if router_utils.HasIncrementalAdvertisementFlags(args):
# This operation should only be run on custom mode peers.
router_utils.ValidateCustomMode(
messages=messages,
resource_class=messages.RouterBgpPeer,
resource=peer)
# These arguments are guaranteed to be mutually exclusive in args.
if args.add_advertisement_groups:
groups_to_add = routers_utils.ParseGroups(
resource_class=messages.RouterBgpPeer,
groups=args.add_advertisement_groups)
peer.advertisedGroups.extend(groups_to_add)
if args.remove_advertisement_groups:
groups_to_remove = routers_utils.ParseGroups(
resource_class=messages.RouterBgpPeer,
groups=args.remove_advertisement_groups)
router_utils.RemoveGroupsFromAdvertisements(
messages=messages,
resource_class=messages.RouterBgpPeer,
resource=peer,
groups=groups_to_remove)
if args.add_advertisement_ranges:
ip_ranges_to_add = routers_utils.ParseIpRanges(
messages=messages, ip_ranges=args.add_advertisement_ranges)
peer.advertisedIpRanges.extend(ip_ranges_to_add)
if args.remove_advertisement_ranges:
router_utils.RemoveIpRangesFromAdvertisements(
messages=messages,
resource_class=messages.RouterBgpPeer,
resource=peer,
ip_ranges=args.remove_advertisement_ranges)
request_type = messages.ComputeRoutersPatchRequest
with holder.client.apitools_client.IncludeFields(cleared_fields):
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='peer [{0}] in router [{1}]'.format(
peer.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 peer [{0}] in router [{1}]'.format(
peer.name, router_ref.Name()))