feat: Add new gcloud commands, API clients, and third-party libraries across various services.

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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.
+"""Commands for reading and manipulating rules in NATs."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+class Rules(base.Group):
+  """List, create, update, describe, and delete Cloud NAT Rules."""
+
+
+Rules.detailed_help = {
+    'DESCRIPTION':
+        """
+        List, create, update, describe, and delete Cloud NAT Rules.
+
+        For more information about Cloud NAT, see the
+        [Cloud NAT documentation](https://cloud.google.com/nat/docs/using-nat).
+    """,
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/create.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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 adding a Rule to a Compute Engine NAT."""
+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.operations import poller
+from googlecloudsdk.api_lib.util import waiter
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute.routers import flags as routers_flags
+from googlecloudsdk.command_lib.compute.routers.nats import nats_utils
+from googlecloudsdk.command_lib.compute.routers.nats.rules import flags as rules_flags
+from googlecloudsdk.command_lib.compute.routers.nats.rules import rules_utils
+from googlecloudsdk.core import log
+from googlecloudsdk.core import resources
+
+
+@base.ReleaseTracks(
+    base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA, base.ReleaseTrack.GA
+)
+class Create(base.CreateCommand):
+  """Add a Rule to a Compute Engine NAT."""
+
+  @classmethod
+  def Args(cls, parser):
+    cls.ROUTER_ARG = routers_flags.RouterArgumentForNat()
+    cls.ROUTER_ARG.AddArgument(parser)
+
+    rules_flags.AddRuleNumberArg(parser, operation_type='create', plural=False)
+    rules_flags.AddNatNameArg(parser)
+    compute_flags.AddRegionFlag(parser, 'NAT', operation_type='create')
+
+    rules_flags.AddMatchArg(parser, required=True)
+    rules_flags.AddIpAndRangeArgsForCreate(parser)
+
+    base.ASYNC_FLAG.AddToParser(parser)
+
+  def Run(self, 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
+    router = service.Get(request_type(**router_ref.AsDict()))
+
+    rule_number = args.rule_number
+    nat_name = args.nat
+
+    existing_nat = nats_utils.FindNatOrRaise(router, nat_name)
+
+    rule = rules_utils.CreateRuleMessage(args, holder, existing_nat)
+    existing_nat.rules.append(rule)
+
+    result = service.Patch(
+        messages.ComputeRoutersPatchRequest(
+            project=router_ref.project,
+            region=router_ref.region,
+            router=router_ref.Name(),
+            routerResource=router))
+
+    operation_ref = resources.REGISTRY.Parse(
+        result.name,
+        collection='compute.regionOperations',
+        params={
+            'project': router_ref.project,
+            'region': router_ref.region,
+        })
+
+    if args.async_:
+      log.CreatedResource(
+          operation_ref,
+          kind='Rule [{0}] in NAT [{1}]'.format(rule_number, nat_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,
+        'Creating Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name))
+
+
+Create.detailed_help = {
+    'DESCRIPTION':
+        """
+        *{command}* is used to create a Rule on a Compute Engine NAT.
+        """,
+    'EXAMPLES':
+        """\
+        Create a rule to use the IP Address address-1 to talk to destination IPs
+        in the CIDR Range "203.0.113.0/24".
+
+          $ {command} 1 --nat=my-nat --router=my-router --region=us-central1
+            --match='inIpRange(destination.ip, "203.0.113.0/24")'
+            --source-nat-active-ips=a1
+        """
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/delete.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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 removing a Rule from a Compute Engine NAT."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+import textwrap
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.api_lib.compute import utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute.routers import flags as routers_flags
+from googlecloudsdk.command_lib.compute.routers.nats import nats_utils
+from googlecloudsdk.command_lib.compute.routers.nats.rules import flags as rules_flags
+from googlecloudsdk.command_lib.compute.routers.nats.rules import rules_utils
+
+
+class Delete(base.DeleteCommand):
+  """Delete a Rule in a Compute Engine NAT."""
+
+  ROUTER_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    cls.ROUTER_ARG = routers_flags.RouterArgumentForNat()
+    cls.ROUTER_ARG.AddArgument(parser)
+
+    rules_flags.AddRuleNumberArg(parser, plural=True)
+    rules_flags.AddNatNameArg(parser)
+    compute_flags.AddRegionFlag(
+        parser, 'NAT containing the Rule', operation_type='delete', plural=True)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    client = holder.client
+
+    router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources)
+
+    objects = client.MakeRequests([
+        (client.apitools_client.routers, 'Get',
+         client.messages.ComputeRoutersGetRequest(**router_ref.AsDict()))
+    ])
+    router = objects[0]
+
+    nat_name = args.nat
+    rule_numbers = args.rule_number
+
+    nat = nats_utils.FindNatOrRaise(router, nat_name)
+    for rule_number in rule_numbers:
+      rule = rules_utils.FindRuleOrRaise(nat, rule_number)
+      nat.rules.remove(rule)
+
+    utils.PromptForDeletionHelper(
+        'Rule', ['{} in NAT {}'.format(args.rule_number, nat_name)])
+
+    return client.MakeRequests(
+        [self._GetPatchRequest(client, router_ref, router)])
+
+  def _GetPatchRequest(self, client, router_ref, router):
+    return (client.apitools_client.routers, 'Patch',
+            client.messages.ComputeRoutersPatchRequest(
+                router=router_ref.Name(),
+                routerResource=router,
+                region=router_ref.region,
+                project=router_ref.project))
+
+
+Delete.detailed_help = {
+    'DESCRIPTION':
+        textwrap.dedent("""\
+          *{command}* is used to delete a Rule on a Compute Engine NAT.
+    """),
+    'EXAMPLES':
+        """\
+    To delete Rule 1 in NAT 'n1' in router 'r1', run:
+
+      $ {command} 1 --nat=n1 --router=r1 --region=us-central1
+    """
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/describe.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2021 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 describing a Rule from a Compute Engine NAT."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+import textwrap
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute.routers import flags as routers_flags
+from googlecloudsdk.command_lib.compute.routers.nats import nats_utils
+from googlecloudsdk.command_lib.compute.routers.nats.rules import flags as rules_flags
+from googlecloudsdk.command_lib.compute.routers.nats.rules import rules_utils
+
+
+class Describe(base.DescribeCommand):
+  """Describe a Rule in a Compute Engine NAT."""
+
+  ROUTER_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    cls.ROUTER_ARG = routers_flags.RouterArgumentForNat()
+    cls.ROUTER_ARG.AddArgument(parser)
+
+    rules_flags.AddRuleNumberArg(parser)
+    rules_flags.AddNatNameArg(parser)
+    compute_flags.AddRegionFlag(
+        parser, 'NAT containing the Rule', operation_type='describe')
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    client = holder.client
+
+    router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources)
+
+    router = client.MakeRequests([
+        (client.apitools_client.routers, 'Get',
+         client.messages.ComputeRoutersGetRequest(**router_ref.AsDict()))
+    ])[0]
+
+    nat_name = args.nat
+    rule_number = args.rule_number
+
+    nat = nats_utils.FindNatOrRaise(router, nat_name)
+
+    return rules_utils.FindRuleOrRaise(nat, rule_number)
+
+
+Describe.detailed_help = {
+    'DESCRIPTION':
+        textwrap.dedent("""\
+          *{command}* is used to describe a Rule on a Compute Engine NAT.
+    """),
+    'EXAMPLES':
+        """\
+    To describe Rule 1 in NAT 'n1' in router 'r1', run:
+
+      $ {command} 1 --nat=n1 --router=r1 --region=us-central1
+    """
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/list.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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 to list NATs on a Compute Engine router."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+import textwrap
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute.routers import flags as routers_flags
+from googlecloudsdk.command_lib.compute.routers.nats import nats_utils
+from googlecloudsdk.command_lib.compute.routers.nats.rules import flags as rules_flags
+
+
+class List(base.DescribeCommand):
+  """Lists the NATs on a Compute Engine router."""
+
+  @classmethod
+  def Args(cls, parser):
+    cls.ROUTER_ARG = routers_flags.RouterArgumentForNat()
+    cls.ROUTER_ARG.AddArgument(parser)
+
+    rules_flags.AddNatNameArg(parser)
+
+    parser.display_info.AddFormat(rules_flags.DEFAULT_LIST_FORMAT)
+
+    compute_flags.AddRegionFlag(
+        parser, 'NAT containing the Rules', operation_type='list')
+
+  def Run(self, 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
+    router = service.Get(request_type(**router_ref.AsDict()))
+
+    nat_name = args.nat
+
+    nat = nats_utils.FindNatOrRaise(router, nat_name)
+
+    return nat.rules
+
+
+List.detailed_help = {
+    'DESCRIPTION':
+        textwrap.dedent("""\
+        *{command}* is used to list the Rule on a Compute Engine NAT.
+     """),
+    'EXAMPLES':
+        """\
+    To list all Rules in Nat ``n1'' in router ``r1'' in region ``us-central1'',
+    run:
+
+        $ {command} --nat=n1 --router=r1 --region=us-central1.
+    """
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/routers/nats/rules/update.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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 Rule in a Compute Engine NAT."""
+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.operations import poller
+from googlecloudsdk.api_lib.util import waiter
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute.routers import flags as routers_flags
+from googlecloudsdk.command_lib.compute.routers.nats import nats_utils
+from googlecloudsdk.command_lib.compute.routers.nats.rules import flags as rules_flags
+from googlecloudsdk.command_lib.compute.routers.nats.rules import rules_utils
+from googlecloudsdk.core import log
+from googlecloudsdk.core import resources
+
+
+@base.ReleaseTracks(
+    base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA, base.ReleaseTrack.GA
+)
+class Update(base.UpdateCommand):
+  """Update a Rule in a Compute Engine NAT."""
+
+  @classmethod
+  def Args(cls, parser):
+    cls.ROUTER_ARG = routers_flags.RouterArgumentForNat()
+    cls.ROUTER_ARG.AddArgument(parser)
+
+    rules_flags.AddRuleNumberArg(parser, operation_type='update', plural=False)
+    rules_flags.AddNatNameArg(parser)
+    compute_flags.AddRegionFlag(
+        parser, 'NAT containing the Rule', operation_type='update'
+    )
+
+    rules_flags.AddMatchArg(parser, required=False)
+    rules_flags.AddIpAndRangeArgsForUpdate(parser)
+
+    base.ASYNC_FLAG.AddToParser(parser)
+
+  def Run(self, 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
+    router = service.Get(request_type(**router_ref.AsDict()))
+
+    rule_number = args.rule_number
+    nat_name = args.nat
+
+    nat = nats_utils.FindNatOrRaise(router, nat_name)
+    rule = rules_utils.FindRuleOrRaise(nat, rule_number)
+
+    rules_utils.UpdateRuleMessage(rule, args, holder, nat)
+
+    result = service.Patch(
+        messages.ComputeRoutersPatchRequest(
+            project=router_ref.project,
+            region=router_ref.region,
+            router=router_ref.Name(),
+            routerResource=router))
+
+    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='Rule [{0}] in NAT [{1}]'.format(rule_number, nat_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 Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name))
+
+
+Update.detailed_help = {
+    'DESCRIPTION':
+        """
+        *{command}* is used to update a Rule in a Compute Engine NAT.
+        """,
+    'EXAMPLES':
+        """\
+        To drain connections established using address-1 and use address-2 for
+        all new connections matching Rule 1 in NAT nat-1, run:
+
+          $ {command} 1 --nat=nat1 --router=my-router --region=us-central1
+            --source-nat-drain-ips=address-1
+            --source-nat-active-ips=address-2
+        """
+}