201 lines
7.0 KiB
Python
201 lines
7.0 KiB
Python
# -*- coding: utf-8 -*- #
|
|
# Copyright 2016 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 access configs for virtual machine instances."""
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import unicode_literals
|
|
|
|
from googlecloudsdk.api_lib.compute import base_classes
|
|
from googlecloudsdk.calliope import base
|
|
from googlecloudsdk.calliope import exceptions
|
|
from googlecloudsdk.command_lib.compute.instances import flags
|
|
from googlecloudsdk.core import log
|
|
|
|
DETAILED_HELP = {
|
|
'DESCRIPTION':
|
|
"""
|
|
*{command}* is used to update access configurations for network
|
|
interfaces of Compute Engine virtual machines. IPv4 and IPv6 access
|
|
configurations cannot be updated together.
|
|
""",
|
|
'EXAMPLES':
|
|
"""
|
|
To update public PTR record in IPv4 access config in network interface 'nic0' of an instance, run:
|
|
|
|
$ {command} example-instance --network-interface=nic0 --zone=us-central1-b \
|
|
--public-ptr --public-ptr-domain=exampledomain.com.
|
|
|
|
To update public PTR record in IPv6 access config in default network interface 'nic0' of an instance, run:
|
|
|
|
$ {command} example-instance --zone=us-central1-b \
|
|
--ipv6-public-ptr-domain=exampledomain.com.
|
|
"""
|
|
}
|
|
|
|
|
|
def _Args(parser, support_public_dns, support_network_tier):
|
|
"""Register parser args common to all tracks."""
|
|
|
|
flags.INSTANCE_ARG.AddArgument(parser)
|
|
flags.AddNetworkInterfaceArgs(parser)
|
|
flags.AddPublicPtrArgs(parser, instance=False)
|
|
flags.AddIpv6PublicPtrArgs(parser)
|
|
if support_public_dns:
|
|
flags.AddPublicDnsArgs(parser, instance=False)
|
|
if support_network_tier:
|
|
flags.AddNetworkTierArgs(parser, instance=False, for_update=True)
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.GA)
|
|
class UpdateAccessConfigInstances(base.UpdateCommand):
|
|
"""Update a Compute Engine virtual machine access configuration."""
|
|
|
|
_support_public_dns = False
|
|
_support_network_tier = False
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
_Args(
|
|
parser,
|
|
support_public_dns=cls._support_public_dns,
|
|
support_network_tier=cls._support_network_tier)
|
|
|
|
def CreateReference(self, client, resources, args):
|
|
return flags.INSTANCE_ARG.ResolveAsResource(
|
|
args, resources, scope_lister=flags.GetInstanceZoneScopeLister(client))
|
|
|
|
def CreateV4AddressConfig(self, client):
|
|
return client.messages.AccessConfig(
|
|
type=client.messages.AccessConfig.TypeValueValuesEnum.ONE_TO_ONE_NAT)
|
|
|
|
def CreateV6AddressConfig(self, client):
|
|
return client.messages.AccessConfig(
|
|
type=client.messages.AccessConfig.TypeValueValuesEnum.DIRECT_IPV6)
|
|
|
|
def GetGetRequest(self, client, instance_ref):
|
|
return (client.apitools_client.instances, 'Get',
|
|
client.messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
|
|
|
|
def GetUpdateRequest(self, client, args, instance_ref, access_config):
|
|
return (client.apitools_client.instances, 'UpdateAccessConfig',
|
|
client.messages.ComputeInstancesUpdateAccessConfigRequest(
|
|
instance=instance_ref.instance,
|
|
networkInterface=args.network_interface,
|
|
accessConfig=access_config,
|
|
project=instance_ref.project,
|
|
zone=instance_ref.zone))
|
|
|
|
# Generate updated AccessConfig for PATCH semantic.
|
|
def Modify(self, client, args, original):
|
|
set_public_dns = None
|
|
if self._support_public_dns:
|
|
if args.public_dns:
|
|
set_public_dns = True
|
|
elif args.no_public_dns:
|
|
set_public_dns = False
|
|
|
|
set_ptr = None
|
|
if args.public_ptr:
|
|
set_ptr = True
|
|
elif args.no_public_ptr:
|
|
set_ptr = False
|
|
|
|
set_ipv6_ptr = None
|
|
if args.ipv6_public_ptr_domain:
|
|
set_ipv6_ptr = True
|
|
elif args.no_ipv6_public_ptr:
|
|
set_ipv6_ptr = False
|
|
|
|
if (set_ptr is not None and set_ipv6_ptr is not None):
|
|
raise exceptions.InvalidArgumentException(
|
|
'--ipv6-public-ptr-domain',
|
|
'Cannot update --public-ptr-domain and --ipv6-public-ptr-domain at same time.'
|
|
)
|
|
|
|
if self._support_public_dns and set_public_dns is not None:
|
|
access_config = self.CreateV4AddressConfig(client)
|
|
access_config.setPublicDns = set_public_dns
|
|
return access_config
|
|
|
|
if set_ptr is not None:
|
|
access_config = self.CreateV4AddressConfig(client)
|
|
access_config.setPublicPtr = set_ptr
|
|
new_ptr = '' if args.public_ptr_domain is None else args.public_ptr_domain
|
|
access_config.publicPtrDomainName = new_ptr
|
|
return access_config
|
|
|
|
if set_ipv6_ptr is not None:
|
|
access_config = self.CreateV6AddressConfig(client)
|
|
new_ptr = '' if args.ipv6_public_ptr_domain is None else args.ipv6_public_ptr_domain
|
|
access_config.publicPtrDomainName = new_ptr
|
|
return access_config
|
|
|
|
if self._support_network_tier and args.network_tier is not None:
|
|
access_config = self.CreateV4AddressConfig(client)
|
|
access_config.networkTier = (
|
|
client.messages.AccessConfig.NetworkTierValueValuesEnum(
|
|
args.network_tier))
|
|
return access_config
|
|
|
|
return None
|
|
|
|
def Run(self, args):
|
|
flags.ValidatePublicPtrFlags(args)
|
|
flags.ValidateIpv6PublicPtrFlags(args)
|
|
if self._support_public_dns:
|
|
flags.ValidatePublicDnsFlags(args)
|
|
if self._support_network_tier:
|
|
flags.ValidateNetworkTierArgs(args)
|
|
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
|
|
client = holder.client
|
|
|
|
instance_ref = self.CreateReference(client, holder.resources, args)
|
|
get_request = self.GetGetRequest(client, instance_ref)
|
|
|
|
objects = client.MakeRequests([get_request])
|
|
|
|
new_access_config = self.Modify(client, args, objects[0])
|
|
|
|
# If Modify() returns None, then there is no work to be done, so we
|
|
# print the resource and return.
|
|
if new_access_config is None:
|
|
log.status.Print('No change requested; skipping update for [{0}].'.format(
|
|
objects[0].name))
|
|
return objects
|
|
|
|
return client.MakeRequests(requests=[
|
|
self.GetUpdateRequest(client, args, instance_ref, new_access_config)
|
|
])
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.BETA)
|
|
class UpdateAccessConfigInstancesBeta(UpdateAccessConfigInstances):
|
|
"""Update a Compute Engine virtual machine access configuration."""
|
|
|
|
_support_public_dns = False
|
|
_support_network_tier = False
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
|
|
class UpdateAccessConfigInstancesAlpha(UpdateAccessConfigInstances):
|
|
"""Update a Compute Engine virtual machine access configuration."""
|
|
|
|
_support_public_dns = True
|
|
_support_network_tier = True
|
|
|
|
|
|
UpdateAccessConfigInstances.detailed_help = DETAILED_HELP
|