426 lines
14 KiB
Python
426 lines
14 KiB
Python
# -*- coding: utf-8 -*- #
|
|
# Copyright 2015 Google LLC. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Command for updating a BGP peer on a Compute Engine router."""
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import unicode_literals
|
|
|
|
from googlecloudsdk.api_lib.compute import base_classes
|
|
from googlecloudsdk.api_lib.compute import routers_utils
|
|
from googlecloudsdk.api_lib.compute.operations import poller
|
|
from googlecloudsdk.api_lib.util import waiter
|
|
from googlecloudsdk.calliope import base
|
|
from googlecloudsdk.command_lib.compute.routers import flags
|
|
from googlecloudsdk.command_lib.compute.routers import router_utils
|
|
from googlecloudsdk.core import log
|
|
from googlecloudsdk.core import resources
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.GA)
|
|
@base.UniverseCompatible
|
|
class UpdateBgpPeer(base.UpdateCommand):
|
|
"""Update a BGP peer on a Compute Engine router."""
|
|
|
|
ROUTER_ARG = None
|
|
|
|
@classmethod
|
|
def _Args(cls, parser):
|
|
cls.ROUTER_ARG = flags.RouterArgument()
|
|
cls.ROUTER_ARG.AddArgument(parser)
|
|
base.ASYNC_FLAG.AddToParser(parser)
|
|
flags.AddBgpPeerArgs(
|
|
parser,
|
|
for_add_bgp_peer=False,
|
|
is_update=True,
|
|
)
|
|
flags.AddUpdateCustomAdvertisementArgs(parser, 'peer')
|
|
flags.AddUpdateCustomLearnedRoutesArgs(parser)
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
cls._Args(parser)
|
|
|
|
def _Run(self, args, support_bfd_mode=False):
|
|
"""Runs the command.
|
|
|
|
Args:
|
|
args: contains arguments passed to the command.
|
|
support_bfd_mode: The flag to indicate whether bfd mode is supported.
|
|
|
|
Returns:
|
|
The result of patching the router updating the bgp peer with the
|
|
information provided in the arguments.
|
|
"""
|
|
# 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 (
|
|
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,
|
|
)
|
|
|
|
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,
|
|
)
|
|
|
|
if args.set_custom_learned_route_ranges is not None:
|
|
peer.customLearnedIpRanges = routers_utils.ParseCustomLearnedIpRanges(
|
|
messages=messages, ip_ranges=args.set_custom_learned_route_ranges
|
|
)
|
|
|
|
# These arguments are guaranteed to be mutually exclusive in args.
|
|
if args.add_custom_learned_route_ranges:
|
|
ip_ranges_to_add = routers_utils.ParseCustomLearnedIpRanges(
|
|
messages=messages, ip_ranges=args.add_custom_learned_route_ranges
|
|
)
|
|
peer.customLearnedIpRanges.extend(ip_ranges_to_add)
|
|
|
|
if args.remove_custom_learned_route_ranges:
|
|
router_utils.RemoveIpRangesFromCustomLearnedRoutes(
|
|
messages=messages,
|
|
peer=peer,
|
|
ip_ranges=args.remove_custom_learned_route_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()
|
|
),
|
|
)
|
|
|
|
def Run(self, args):
|
|
"""See base.UpdateCommand."""
|
|
return self._Run(args)
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.BETA)
|
|
class UpdateBgpPeerBeta(UpdateBgpPeer):
|
|
"""Update a BGP peer on a Compute Engine router."""
|
|
|
|
ROUTER_ARG = None
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
cls._Args(parser)
|
|
|
|
def Run(self, args):
|
|
"""Runs the command.
|
|
|
|
Args:
|
|
args: contains arguments passed to the command.
|
|
|
|
Returns:
|
|
The result of patching the router updating the bgp peer with the
|
|
information provided in the arguments.
|
|
"""
|
|
return self._Run(args, support_bfd_mode=False)
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
|
|
class UpdateBgpPeerAlpha(UpdateBgpPeerBeta):
|
|
"""Update a BGP peer on a Compute Engine router."""
|
|
|
|
ROUTER_ARG = None
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
cls._Args(parser)
|
|
|
|
def Run(self, args):
|
|
"""Runs the command.
|
|
|
|
Args:
|
|
args: contains arguments passed to the command.
|
|
|
|
Returns:
|
|
The result of patching the router updating the bgp peer with the
|
|
information provided in the arguments.
|
|
"""
|
|
return self._Run(args, support_bfd_mode=True)
|
|
|
|
|
|
def _UpdateBgpPeerMessage(
|
|
peer,
|
|
messages,
|
|
args,
|
|
md5_authentication_key_name,
|
|
support_bfd_mode=False,
|
|
):
|
|
"""Updates base attributes of a BGP peer based on flag arguments."""
|
|
|
|
attrs = {
|
|
'interfaceName': args.interface,
|
|
'ipAddress': args.ip_address,
|
|
'peerIpAddress': args.peer_ip_address,
|
|
'peerAsn': args.peer_asn,
|
|
'advertisedRoutePriority': args.advertised_route_priority,
|
|
}
|
|
|
|
if args.enabled is not None:
|
|
if args.enabled:
|
|
attrs['enable'] = messages.RouterBgpPeer.EnableValueValuesEnum.TRUE
|
|
else:
|
|
attrs['enable'] = messages.RouterBgpPeer.EnableValueValuesEnum.FALSE
|
|
if args.enable_ipv6 is not None:
|
|
attrs['enableIpv6'] = args.enable_ipv6
|
|
if args.ipv6_nexthop_address is not None:
|
|
attrs['ipv6NexthopAddress'] = args.ipv6_nexthop_address
|
|
if args.peer_ipv6_nexthop_address is not None:
|
|
attrs['peerIpv6NexthopAddress'] = args.peer_ipv6_nexthop_address
|
|
if args.enable_ipv4 is not None:
|
|
attrs['enableIpv4'] = args.enable_ipv4
|
|
if args.ipv4_nexthop_address is not None:
|
|
attrs['ipv4NexthopAddress'] = args.ipv4_nexthop_address
|
|
if args.peer_ipv4_nexthop_address is not None:
|
|
attrs['peerIpv4NexthopAddress'] = args.peer_ipv4_nexthop_address
|
|
if args.custom_learned_route_priority is not None:
|
|
attrs['customLearnedRoutePriority'] = args.custom_learned_route_priority
|
|
if args.md5_authentication_key is not None:
|
|
attrs['md5AuthenticationKeyName'] = md5_authentication_key_name
|
|
attrs['exportPolicies'] = args.export_policies
|
|
attrs['importPolicies'] = args.import_policies
|
|
for attr, value in attrs.items():
|
|
if value is not None:
|
|
setattr(peer, attr, value)
|
|
if args.clear_md5_authentication_key:
|
|
peer.md5AuthenticationKeyName = None
|
|
if support_bfd_mode:
|
|
bfd = _UpdateBgpPeerBfdMessageMode(messages, peer, args)
|
|
else:
|
|
bfd = _UpdateBgpPeerBfdMessage(messages, peer, args)
|
|
if bfd is not None:
|
|
setattr(peer, 'bfd', bfd)
|
|
|
|
|
|
def _UpdateBgpPeerBfdMessage(messages, peer, args):
|
|
"""Updates BGP peer BFD messages based on flag arguments."""
|
|
if not (
|
|
args.IsSpecified('bfd_min_receive_interval')
|
|
or args.IsSpecified('bfd_min_transmit_interval')
|
|
or args.IsSpecified('bfd_session_initialization_mode')
|
|
or args.IsSpecified('bfd_multiplier')
|
|
):
|
|
return None
|
|
if peer.bfd is not None:
|
|
bfd = peer.bfd
|
|
else:
|
|
bfd = messages.RouterBgpPeerBfd()
|
|
attrs = {}
|
|
if args.bfd_session_initialization_mode is not None:
|
|
attrs['sessionInitializationMode'] = (
|
|
messages.RouterBgpPeerBfd.SessionInitializationModeValueValuesEnum(
|
|
args.bfd_session_initialization_mode
|
|
)
|
|
)
|
|
attrs['minReceiveInterval'] = args.bfd_min_receive_interval
|
|
attrs['minTransmitInterval'] = args.bfd_min_transmit_interval
|
|
attrs['multiplier'] = args.bfd_multiplier
|
|
for attr, value in attrs.items():
|
|
if value is not None:
|
|
setattr(bfd, attr, value)
|
|
return bfd
|
|
|
|
|
|
def _UpdateBgpPeerBfdMessageMode(messages, peer, args):
|
|
"""Updates BGP peer BFD messages based on flag arguments."""
|
|
if not (
|
|
args.IsSpecified('bfd_min_receive_interval')
|
|
or args.IsSpecified('bfd_min_transmit_interval')
|
|
or args.IsSpecified('bfd_session_initialization_mode')
|
|
or args.IsSpecified('bfd_multiplier')
|
|
):
|
|
return None
|
|
if peer.bfd is not None:
|
|
bfd = peer.bfd
|
|
else:
|
|
bfd = messages.RouterBgpPeerBfd()
|
|
attrs = {}
|
|
if args.bfd_session_initialization_mode is not None:
|
|
attrs['mode'] = messages.RouterBgpPeerBfd.ModeValueValuesEnum(
|
|
args.bfd_session_initialization_mode
|
|
)
|
|
attrs['sessionInitializationMode'] = (
|
|
messages.RouterBgpPeerBfd.SessionInitializationModeValueValuesEnum(
|
|
args.bfd_session_initialization_mode
|
|
)
|
|
)
|
|
attrs['minReceiveInterval'] = args.bfd_min_receive_interval
|
|
attrs['minTransmitInterval'] = args.bfd_min_transmit_interval
|
|
attrs['multiplier'] = args.bfd_multiplier
|
|
for attr, value in attrs.items():
|
|
if value is not None:
|
|
setattr(bfd, attr, value)
|
|
return bfd
|
|
|
|
|
|
UpdateBgpPeer.detailed_help = {
|
|
'DESCRIPTION': """
|
|
*{command}* is used to update a BGP peer on a Compute Engine
|
|
router.
|
|
""",
|
|
}
|