text: # Copyright 2017 Google Inc. 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 simulating maintenance events on virtual machine instances."""
  
  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
  from googlecloudsdk.command_lib.compute.instances import flags as instance_flags
  from googlecloudsdk.core import exceptions as core_exceptions
  from googlecloudsdk.core import log
  
  
  @base.ReleaseTracks(base.ReleaseTrack.ALPHA)
  class SimulateMaintenanceEvent(base.UpdateCommand):
    """Simulate maintenance of virtual machine instances."""
  
    @staticmethod
    def Args(parser):
      instance_flags.INSTANCES_ARG.AddArgument(parser)
      base.ASYNC_FLAG.AddToParser(parser)
  
    def Run(self, args):
  
      holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
      client = holder.client.apitools_client
      messages = holder.client.messages
  
      instance_refs = instance_flags.INSTANCES_ARG.ResolveAsResource(
          args,
          holder.resources,
          scope_lister=flags.GetDefaultScopeLister(client))
  
      requests = []
      for instance_ref in instance_refs:
        request = messages.ComputeInstancesSimulateMaintenanceEventRequest(
            **instance_ref.AsDict())
        requests.append((client.instances, 'SimulateMaintenanceEvent', request))
  
      errors_to_collect = []
      responses = holder.client.BatchRequests(requests, errors_to_collect)
      for r in responses:
        err = getattr(r, 'error', None)
        if err:
          errors_to_collect.append(poller.OperationErrors(err.errors))
      if errors_to_collect:
        raise core_exceptions.MultiError(errors_to_collect)
  
      operation_refs = [holder.resources.Parse(r.selfLink) for r in responses]
  
      if args.async:
        for i, operation_ref in enumerate(operation_refs):
          log.UpdatedResource(
              operation_ref,
              kind='gce instance [{0}]'.format(instance_refs[i].Name()),
              async=True,
              details='Use [gcloud compute operations describe] command '
              'to check the status of this operation.')
        return responses
  
      operation_poller = poller.BatchPoller(holder.client, client.instances,
                                            instance_refs)
      return waiter.WaitFor(
          operation_poller,
          poller.OperationBatch(operation_refs),
          'Simulating maintenance on instance(s) [{0}]'
          .format(', '.join(i.SelfLink() for i in instance_refs)))
  
  
  SimulateMaintenanceEvent.detailed_help = {
      'brief':
          'Simulate maintenance of virtual machine instances',
      'DESCRIPTION':
          """\
          *{command}* simulates a maintenance event on Google
          Compute Engine virtual machines.
          """,
  }
  