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

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/__init__.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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 group for Cloud Monitoring policies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+@base.ReleaseTracks(
+    base.ReleaseTrack.GA, base.ReleaseTrack.BETA, base.ReleaseTrack.ALPHA
+)
+@base.DefaultUniverseOnly
+class Policies(base.Group):
+  """Manage Cloud Monitoring alerting policies."""
+
+  detailed_help = {
+      'DESCRIPTION': """\
+          Manage Monitoring alerting policies.
+
+          More information can be found here:
+          https://cloud.google.com/monitoring/api/v3/
+      """
+  }

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/conditions/__init__.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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 group for Cloud Monitoring Alert Policy conditions."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+@base.ReleaseTracks(
+    base.ReleaseTrack.GA, base.ReleaseTrack.BETA, base.ReleaseTrack.ALPHA
+)
+@base.DefaultUniverseOnly
+class Conditions(base.Group):
+  """Manage Cloud Monitoring alerting policy conditions."""
+
+  detailed_help = {
+      'DESCRIPTION': """\
+          Manage Monitoring alerting policies conditions.
+
+          More information can be found here:
+          https://cloud.google.com/monitoring/api/v3/
+      """
+  }

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/conditions/create.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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.
+"""`gcloud monitoring policies conditions create` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import flags
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+
+
+@base.DefaultUniverseOnly
+class Create(base.CreateCommand):
+  """Create a condition in an alerting policy."""
+
+  @staticmethod
+  def Args(parser):
+    condition_arg = resource_args.CreateAlertPolicyResourceArg(
+        'to add a condition to.')
+    resource_args.AddResourceArgs(parser, [condition_arg])
+    flags.AddMessageFlags(parser, 'condition')
+    flags.AddConditionSettingsFlags(parser)
+
+  def Run(self, args):
+    client = policies.AlertPolicyClient()
+    messages = client.messages
+
+    policy_ref = args.CONCEPTS.alert_policy.Parse()
+    condition = util.GetConditionFromArgs(args, messages)
+
+    policy = client.Get(policy_ref)
+    policy.conditions.append(condition)
+
+    response = client.Update(policy_ref, policy)
+    return response

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/conditions/delete.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2017 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.
+"""`gcloud monitoring policies conditions delete` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+from googlecloudsdk.core import log
+
+
+class Delete(base.CreateCommand):
+  """Delete a condition in an alerting policy.
+
+  Delete a condition in an alerting policy. If the specified condition does
+  not exist, this command will fail with an error. This will not delete
+  the policy if no conditions exist.
+  """
+
+  @staticmethod
+  def Args(parser):
+    condition_arg = resource_args.CreateConditionResourceArg('delete')
+    resource_args.AddResourceArgs(parser, [condition_arg])
+
+  def Run(self, args):
+    client = policies.AlertPolicyClient()
+    condition_ref = args.CONCEPTS.condition.Parse()
+    policy_ref = condition_ref.Parent()
+    policy = client.Get(policy_ref)
+
+    policy = util.RemoveConditionFromPolicy(condition_ref.RelativeName(),
+                                            policy)
+
+    response = client.Update(policy_ref, policy)
+    log.DeletedResource(condition_ref.RelativeName(), 'Condition')
+    return response

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/conditions/describe.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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.
+"""`gcloud monitoring policies conditions describe` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+
+
+class Describe(base.CreateCommand):
+  """Describe a condition in a Cloud Monitoring alerting policy."""
+
+  @staticmethod
+  def Args(parser):
+    condition_arg = resource_args.CreateConditionResourceArg(
+        'describe')
+    resource_args.AddResourceArgs(parser, [condition_arg])
+
+  def Run(self, args):
+    client = policies.AlertPolicyClient()
+    condition_ref = args.CONCEPTS.condition.Parse()
+    policy_ref = condition_ref.Parent()
+    policy = client.Get(policy_ref)
+
+    condition = util.GetConditionFromPolicy(condition_ref.RelativeName(),
+                                            policy)
+
+    return condition

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/conditions/update.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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.
+"""`gcloud monitoring policies conditions update` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import flags
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+
+
+class Update(base.CreateCommand):
+  """Update a condition in an alerting policy."""
+
+  @staticmethod
+  def Args(parser):
+    condition_arg = resource_args.CreateConditionResourceArg('update')
+    resource_args.AddResourceArgs(parser, [condition_arg])
+    flags.AddDisplayNameFlag(parser, 'Condition')
+    flags.AddUpdateableConditionFlags(parser)
+
+  def Run(self, args):
+    util.ValidateUpdateArgsSpecified(
+        args,
+        ['display_name', 'trigger_count', 'trigger_percent', 'if_value'],
+        'condition')
+
+    client = policies.AlertPolicyClient()
+    messages = client.messages
+
+    condition_ref = args.CONCEPTS.condition.Parse()
+    policy_ref = condition_ref.Parent()
+    policy = client.Get(policy_ref)
+
+    condition = util.GetConditionFromPolicy(condition_ref.RelativeName(),
+                                            policy)
+    nested_condition = condition.conditionAbsent or condition.conditionThreshold
+
+    if args.display_name:
+      condition.displayName = args.display_name
+
+    if args.trigger_count or args.trigger_percent:
+      nested_condition.trigger = messages.Trigger(
+          count=args.trigger_count, percent=args.trigger_percent)
+
+    if args.if_value is not None:
+      # Copy existing condition properties into kwargs.
+      kwargs = {
+          'trigger_count': nested_condition.trigger.count,
+          'trigger_percent': nested_condition.trigger.percent,
+          'aggregations': nested_condition.aggregations,
+          'duration': nested_condition.duration,
+          'condition_filter': nested_condition.filter,
+          'if_value': args.if_value
+      }
+
+      # If any trigger values are specified, overwrite whats in args.
+      if args.trigger_count or args.trigger_percent:
+        kwargs['trigger_count'] = args.trigger_count
+        kwargs['trigger_percent'] = args.trigger_percent
+
+      # Clear nested condition messages as this can potentially change.
+      condition.conditionAbsent = None
+      condition.conditionThreshold = None
+
+      # This will change condition in place.
+      util.BuildCondition(messages, condition=condition, **kwargs)
+
+    return client.Update(policy_ref, policy, fields='conditions')

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/config/__init__.py

@@ -0,0 +1,26 @@
+# -*- 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 group for managing Monitoring alert policy configurations."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class Config(base.Group):
+  """Manage Monitoring alert policy configurations."""

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/config/export.yaml

@@ -0,0 +1,38 @@
+release_tracks: [ALPHA]
+command_type: CONFIG_EXPORT
+help_text:
+  brief: Export the configuration for a Monitoring alert policy.
+  description: |
+    *{command}* exports the configuration for a Monitoring alert policy.
+
+    Alert policy configurations can be exported in
+    Kubernetes Resource Model (krm) or Terraform HCL formats. The
+    default format is `krm`.
+
+    Specifying `--all` allows you to export the configurations for all
+    alert policies within the project.
+
+    Specifying `--path` allows you to export the configuration(s) to
+    a local directory.
+  examples: |
+    To export the configuration for an alert policy, run:
+
+      $ {command} my-alert-policy
+
+    To export the configuration for an alert policy to a file, run:
+
+      $ {command} my-alert-policy --path=/path/to/dir/
+
+    To export the configuration for an alert policy in Terraform
+    HCL format, run:
+
+      $ {command} my-alert-policy --resource-format=terraform
+
+    To export the configurations for all alert policies within a
+    project, run:
+
+      $ {command} --all
+arguments:
+  resource:
+    help_text: Alert policy to export the configuration for.
+    spec: !REF googlecloudsdk.command_lib.monitoring.resources:policy

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/create.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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.
+"""`gcloud monitoring policies create` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import flags
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+from googlecloudsdk.command_lib.projects import util as projects_util
+from googlecloudsdk.core import log
+from googlecloudsdk.core import properties
+
+
+@base.DefaultUniverseOnly
+class Create(base.CreateCommand):
+  """Create a new alerting policy."""
+
+  detailed_help = {
+      'DESCRIPTION': """\
+          Creates a new alerting policy. An alert policy can be specified as a
+          JSON/YAML value passed in as a string through the `--policy` flag or
+          as a file through the `--policy-from-file` flag. A basic policy can
+          also be specified through command line flags. If a policy is specified
+          through `--policy` or `--policy-from-file`, and additional flags are
+          supplied, the flags will override the policy's settings and a
+          specified condition will be appended to the list of conditions.
+
+          For information about the JSON/YAML format of an alerting policy:
+          https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.alertPolicies
+       """
+  }
+
+  @staticmethod
+  def Args(parser):
+    flags.AddMessageFlags(parser, 'policy')
+    flags.AddPolicySettingsFlags(parser)
+    flags.AddConditionSettingsFlags(parser)
+    channels_resource_arg = resource_args.CreateNotificationChannelResourceArg(
+        arg_name='--notification-channels',
+        extra_help="""\
+            to be added to the policy. These should be the resource names (not
+            the display name) of the channels. Acceptable formats are:
+
+            * Channel Name: `my-channel`
+              * The project specified through `--project` or the default
+                project defined by the `core/project` property will be used,
+                in that order.
+            * Channel Relative Name:
+                `projects/my-project/notificationChannels/channel-id0`
+            * Channel URI:
+                https://monitoring.{universe_domain}/v3/projects/my-project/notificationChannels/channel-id0
+            """.format(
+            universe_domain=properties.VALUES.core.universe_domain.Get()
+        ),
+        required=False,
+        plural=True,
+    )
+    resource_args.AddResourceArgs(parser, [channels_resource_arg])
+
+  def Run(self, args):
+    client = policies.AlertPolicyClient()
+    messages = client.messages
+    policy = util.CreateAlertPolicyFromArgs(args, client.messages)
+
+    if args.user_labels:
+      policy.userLabels = util.ParseCreateLabels(
+          args.user_labels, messages.AlertPolicy.UserLabelsValue)
+
+    project_ref = (
+        projects_util.ParseProject(properties.VALUES.core.project.Get()))
+
+    result = client.Create(project_ref, policy)
+    log.CreatedResource(result.name, 'alert policy')
+    return result

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/delete.yaml

@@ -0,0 +1,11 @@
+- help_text:
+    brief: Delete a Cloud Monitoring alerting policy.
+    description: Delete a Monitoring alerting policy.
+
+  request:
+    collection: monitoring.projects.alertPolicies
+
+  arguments:
+    resource:
+      help_text: The alerting policy to delete.
+      spec: !REF googlecloudsdk.command_lib.monitoring.resources:policy

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/describe.yaml

@@ -0,0 +1,11 @@
+- help_text:
+    brief: Describe an  alerting policy.
+    description: Describe an alerting policy.
+
+  request:
+    collection: monitoring.projects.alertPolicies
+
+  arguments:
+    resource:
+      help_text: The alerting policy to describe.
+      spec: !REF googlecloudsdk.command_lib.monitoring.resources:policy

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/list.yaml

@@ -0,0 +1,40 @@
+- help_text:
+    brief: List alerting policies.
+    description: List alerting policies.
+    examples: |
+      To order your results first by the team key in user_labels and
+      then the policy's display name:
+
+        $ {command} --sort-by user_label.team,display_name
+
+      To order your results in reverse order, you can add either '~' or '-'
+      in front of the field name:
+
+        $ {command} --sort-by "-display_name"
+
+      To return results with non-empty display names or descriptions:
+
+        $ {command} --filter "(NOT display_name.empty OR NOT description.empty)"
+
+      To return results whose descriptions contain the word 'cloud':
+
+        $ {command} --filter "description:(cloud)"
+
+      Please find all supported fields at
+      https://cloud.google.com/monitoring/api/v3/sorting-and-filtering#alertpolicy.
+
+  request:
+    collection: monitoring.projects.alertPolicies
+    modify_request_hooks:
+    - googlecloudsdk.command_lib.monitoring.hooks:AddOrderByToListRequest
+
+  response:
+    id_field: name
+
+  arguments:
+    resource:
+      help_text: The Cloud Monitoring Workspace from which to list policies from.
+      spec: !REF googlecloudsdk.command_lib.monitoring.resources:project
+
+  output:
+    format: yaml

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/migrate.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2023 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.
+"""`gcloud monitoring policies migrate` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import channels
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import flags
+from googlecloudsdk.command_lib.monitoring import util
+from googlecloudsdk.command_lib.projects import util as projects_util
+from googlecloudsdk.core import log
+from googlecloudsdk.core import properties
+from googlecloudsdk.core.console import console_io
+
+
+class Migrate(base.CreateCommand):
+  """Migrate a Prometheus configuration file to Cloud Monitoring."""
+
+  detailed_help = {'DESCRIPTION': """\
+          Creates new alerting policies and/or notification channels based on
+          provided Prometheus files. The rules YAML file, which holds the alert
+          rules, must be specified as a file through the
+          `--policies-from-prometheus-alert-rules-yaml` flag.
+       """}
+
+  @staticmethod
+  def Args(parser):
+    flags.AddMigrateFlags(parser)
+
+  def Run(self, args):
+    notification_channel_client = channels.NotificationChannelsClient()
+    alert_policy_client = policies.AlertPolicyClient()
+    promql_flags = [
+        '--policies-from-prometheus-alert-rules-yaml',
+        '--channels-from-prometheus-alertmanager-yaml',
+    ]
+    util.ValidateAtleastOneSpecified(args, promql_flags)
+    project_ref = projects_util.ParseProject(
+        properties.VALUES.core.project.Get()
+    )
+
+    if not console_io.PromptContinue(
+        message=(
+            'Each call of the migration tool will create a new set of alert'
+            ' policies and/or notification channels. Thus, the migration tool'
+            ' should not be used to update existing alert policies and/or'
+            ' notification channels.'
+        ),
+        default=False,
+    ):
+      return
+
+    notification_channels = util.CreateNotificationChannelsFromArgs(
+        args, alert_policy_client.messages
+    )
+
+    created_channel_names = []
+    for channel in notification_channels:
+      result = notification_channel_client.Create(project_ref, channel)
+      log.CreatedResource(result.name, 'notification channel')
+      created_channel_names.append(result.name)
+
+    promql_policies = util.CreatePromQLPoliciesFromArgs(
+        args, alert_policy_client.messages, created_channel_names
+    )
+
+    policies_results = []
+    # might be good to have a rollback mechanism for when a subset of the
+    # creations fails. In this case, should we delete the already
+    # created policies?
+    for policy in promql_policies:
+      result = alert_policy_client.Create(project_ref, policy)
+      log.CreatedResource(result.name, 'alert policy')
+      policies_results.append(result)
+    return policies_results

gcloud auth application-default login/google-cloud-sdk/lib/surface/monitoring/policies/update.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2018 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.
+"""`gcloud monitoring policies update` command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.monitoring import policies
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.monitoring import flags
+from googlecloudsdk.command_lib.monitoring import resource_args
+from googlecloudsdk.command_lib.monitoring import util
+from googlecloudsdk.command_lib.util.args import repeated
+
+
+class Update(base.CreateCommand):
+  """Updates an alerting policy."""
+
+  detailed_help = {
+      'DESCRIPTION': """\
+          Updates an alerting policy.
+
+          If `--policy` or `--policy-from-file` are specified:
+
+            * If `--fields` is specified, the only the specified fields will be
+              updated.
+            * Else, the policy will be replaced with the provided policy. The
+              policy can be modified further using the flags from the Policy
+              Settings group below.
+
+          Otherwise, the policy will be updated with the values specified in
+          the flags from the Policy Settings group.
+
+          For information about the JSON/YAML format of an alerting policy:
+          https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.alertPolicies
+       """
+  }
+
+  @staticmethod
+  def Args(parser):
+    resources = [
+        resource_args.CreateAlertPolicyResourceArg('to be updated.')]
+    resource_args.AddResourceArgs(parser, resources)
+    flags.AddMessageFlags(parser, 'policy')
+    flags.AddFieldsFlagsWithMutuallyExclusiveSettings(
+        parser,
+        fields_help=('The list of fields to update. Must specify `--policy` or '
+                     '`--policy-from-file` if using this flag.'),
+        add_settings_func=flags.AddPolicySettingsFlags,
+        fields_choices=['disabled', 'notificationChannels'],
+        update=True)
+
+  def Run(self, args):
+    util.ValidateUpdateArgsSpecified(
+        args,
+        ['policy', 'policy_from_file', 'display_name', 'enabled',
+         'add_notification_channels', 'remove_notification_channels',
+         'set_notification_channels',
+         'clear_notification_channels', 'documentation', 'documentation_format',
+         'documentation_from_file', 'fields', 'update_user_labels',
+         'remove_user_labels', 'clear_user_labels'],
+        'policy')
+    flags.ValidateAlertPolicyUpdateArgs(args)
+
+    client = policies.AlertPolicyClient()
+    messages = client.messages
+
+    passed_yaml_policy = False
+    policy_ref = args.CONCEPTS.alert_policy.Parse()
+    if args.policy or args.policy_from_file:
+      passed_yaml_policy = True
+      policy = util.GetBasePolicyMessageFromArgs(args, messages.AlertPolicy)
+    else:
+      # If a full policy isn't given, we want to do Read-Modify-Write.
+      policy = client.Get(policy_ref)
+
+    if not args.fields:
+      channels = policy.notificationChannels
+      new_channels = repeated.ParseResourceNameArgs(
+          args, 'notification_channels', lambda: channels,
+          util.ParseNotificationChannel)
+      enabled = args.enabled if args.IsSpecified('enabled') else None
+
+      fields = []
+      util.ModifyAlertPolicy(
+          policy,
+          messages,
+          display_name=args.display_name,
+          documentation_content=
+          args.documentation or args.documentation_from_file,
+          documentation_format=args.documentation_format,
+          enabled=enabled,
+          channels=new_channels,
+          field_masks=fields)
+
+      new_labels = util.ProcessUpdateLabels(
+          args,
+          'user_labels',
+          messages.AlertPolicy.UserLabelsValue,
+          policy.userLabels)
+      if new_labels:
+        policy.userLabels = new_labels
+        # TODO(b/73120276): Use field masks per key for label updates.
+        fields.append('user_labels')
+
+      # For more robust concurrent updates, use update masks if we're not
+      # trying to replace the policy using --policy or --policy-from-file.
+      fields = None if passed_yaml_policy else ','.join(sorted(fields))
+    else:
+      fields = ','.join(args.fields)
+
+    return client.Update(policy_ref, policy, fields)