Ejemplo n.º 1
0
  def Run(self, args):
    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
    client = holder.client.apitools_client
    messages = holder.client.messages

    forwarding_rule_ref = self.FORWARDING_RULE_ARG.ResolveAsResource(
        args,
        holder.resources,
        scope_lister=compute_flags.GetDefaultScopeLister(holder.client))

    update_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
    remove_labels = labels_util.GetRemoveLabelsListFromArgs(args)
    if update_labels is None and remove_labels is None:
      raise calliope_exceptions.RequiredArgumentException(
          'LABELS', 'At least one of --update-labels or '
          '--remove-labels must be specified.')

    if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules':
      forwarding_rule = client.globalForwardingRules.Get(
          messages.ComputeGlobalForwardingRulesGetRequest(
              **forwarding_rule_ref.AsDict()))
      labels_value = messages.GlobalSetLabelsRequest.LabelsValue
    else:
      forwarding_rule = client.forwardingRules.Get(
          messages.ComputeForwardingRulesGetRequest(
              **forwarding_rule_ref.AsDict()))
      labels_value = messages.RegionSetLabelsRequest.LabelsValue

    replacement = labels_util.UpdateLabels(
        forwarding_rule.labels,
        labels_value,
        update_labels=update_labels,
        remove_labels=remove_labels)

    if not replacement:
      return forwarding_rule

    if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules':
      request = self._CreateGlobalSetLabelsRequest(
          messages, forwarding_rule_ref, forwarding_rule, replacement)

      operation = client.globalForwardingRules.SetLabels(request)
      operation_ref = holder.resources.Parse(
          operation.selfLink, collection='compute.globalOperations')

      operation_poller = poller.Poller(client.globalForwardingRules)
    else:
      request = self._CreateRegionalSetLabelsRequest(
          messages, forwarding_rule_ref, forwarding_rule, replacement)

      operation = client.forwardingRules.SetLabels(request)
      operation_ref = holder.resources.Parse(
          operation.selfLink, collection='compute.regionOperations')

      operation_poller = poller.Poller(client.forwardingRules)

    return waiter.WaitFor(operation_poller, operation_ref,
                          'Updating labels of forwarding rule [{0}]'.format(
                              forwarding_rule_ref.Name()))
Ejemplo n.º 2
0
    def _Run(self, args, support_user_licenses=False):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        disk_ref = self.DISK_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))
        disk_info = api_util.GetDiskInfo(disk_ref, client, messages)
        service = disk_info.GetService()

        if support_user_licenses and args.IsSpecified(
                'zone') and _UserLicensesFlagsIncluded(args):
            disk_res = messages.Disk(name=disk_ref.Name())
            if args.IsSpecified('update_user_licenses'):
                disk_res.userLicenses = args.update_user_licenses
            disk_update_request = messages.ComputeDisksUpdateRequest(
                project=disk_ref.project,
                disk=disk_ref.Name(),
                diskResource=disk_res,
                zone=disk_ref.zone,
                paths=['userLicenses'])

            update_operation = service.Update(disk_update_request)
            update_operation_ref = holder.resources.Parse(
                update_operation.selfLink,
                collection=disk_info.GetOperationCollection())
            update_operation_poller = poller.Poller(service)
            result = waiter.WaitFor(
                update_operation_poller, update_operation_ref,
                'Updating user licenses of disk [{0}]'.format(disk_ref.Name()))
            if not _LabelsFlagsIncluded(args):
                return result

        labels_diff = labels_util.GetAndValidateOpsFromArgs(args)

        disk = disk_info.GetDiskResource()

        set_label_req = disk_info.GetSetLabelsRequestMessage()
        labels_update = labels_diff.Apply(set_label_req.LabelsValue,
                                          disk.labels)
        request = disk_info.GetSetDiskLabelsRequestMessage(
            disk, labels_update.GetOrNone())

        if not labels_update.needs_update:
            return disk

        operation = service.SetLabels(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection=disk_info.GetOperationCollection())

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of disk [{0}]'.format(disk_ref.Name()))
Ejemplo n.º 3
0
    def Run(self, args):
        """Issues requests necessary to update Container."""
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client

        instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=instances_flags.GetInstanceZoneScopeLister(client))

        # fetch the Instance resource
        instance = client.apitools_client.instances.Get(
            client.messages.ComputeInstancesGetRequest(
                **instance_ref.AsDict()))

        # find gce-container-declaration metadata entry
        for metadata in instance.metadata.items:
            if metadata.key == containers_utils.GCE_CONTAINER_DECLARATION:
                # update gce-container-declaration
                containers_utils.UpdateMetadata(metadata, args)

                # update Google Compute Engine resource
                operation = client.apitools_client.instances.SetMetadata(
                    client.messages.ComputeInstancesSetMetadataRequest(
                        metadata=instance.metadata, **instance_ref.AsDict()))

                operation_ref = holder.resources.Parse(
                    operation.selfLink, collection='compute.zoneOperations')

                operation_poller = poller.Poller(
                    client.apitools_client.instances)
                waiter.WaitFor(
                    operation_poller, operation_ref,
                    'Updating specification of container [{0}]'.format(
                        instance_ref.Name()))

                # restart the Virtual Machine
                operation = client.apitools_client.instances.Reset(
                    client.messages.ComputeInstancesResetRequest(
                        **instance_ref.AsDict()))

                operation_ref = holder.resources.Parse(
                    operation.selfLink, collection='compute.zoneOperations')

                operation_poller = poller.Poller(
                    client.apitools_client.instances)
                return waiter.WaitFor(
                    operation_poller, operation_ref,
                    'Restarting container [{0}]'.format(instance_ref.Name()))

        raise containers_utils.NoGceContainerDeclarationMetadataKey()
Ejemplo n.º 4
0
    def Run(self, args):
        """Issues the request to delete Signed URL key from the backend bucket."""
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        api_client = holder.client.apitools_client
        messages = holder.client.messages
        service = api_client.backendServices

        backend_service_ref = flags.GLOBAL_BACKEND_SERVICE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
        request = messages.ComputeBackendServicesDeleteSignedUrlKeyRequest(
            project=backend_service_ref.project,
            backendService=backend_service_ref.Name(),
            keyName=args.key_name)

        operation = service.DeleteSignedUrlKey(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection='compute.globalOperations')

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Deleting Cloud CDN Signed URL key from [{0}]'.format(
                backend_service_ref.Name()))
Ejemplo n.º 5
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        image_ref = self.DISK_IMAGE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))

        add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)

        image = client.images.Get(
            messages.ComputeImagesGetRequest(**image_ref.AsDict()))

        replacement = labels_util.Diff(additions=add_labels).Apply(
            messages.GlobalSetLabelsRequest.LabelsValue, image.labels)

        if not replacement:
            return image

        request = messages.ComputeImagesSetLabelsRequest(
            project=image_ref.project,
            resource=image_ref.image,
            globalSetLabelsRequest=messages.GlobalSetLabelsRequest(
                labelFingerprint=image.labelFingerprint, labels=replacement))

        operation = client.images.SetLabels(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection='compute.globalOperations')

        operation_poller = poller.Poller(client.images)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of image [{0}]'.format(image_ref.Name()))
Ejemplo n.º 6
0
    def Run(self, args):
        """Issues the request to add Signed URL key to the backend service."""
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        api_client = holder.client.apitools_client
        messages = holder.client.messages
        service = api_client.backendBuckets

        backend_bucket_ref = self.BACKEND_BUCKET_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
        key_value = files.ReadFileContents(args.key_file).rstrip()
        request = messages.ComputeBackendBucketsAddSignedUrlKeyRequest(
            project=backend_bucket_ref.project,
            backendBucket=backend_bucket_ref.Name(),
            signedUrlKey=messages.SignedUrlKey(keyName=args.key_name,
                                               keyValue=key_value))

        operation = service.AddSignedUrlKey(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection='compute.globalOperations')

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Adding Cloud CDN Signed URL key to [{0}]'.format(
                backend_bucket_ref.Name()))
Ejemplo n.º 7
0
    def Run(self, args):
        instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs(
            args, need_disk_source=True)

        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client
        resources = holder.resources

        igm_ref = (
            instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
            ResolveAsResource)(
                args,
                resources,
                scope_lister=compute_flags.GetDefaultScopeLister(client))

        instance_ref = self._CreateNewInstanceReference(
            holder=holder, igm_ref=igm_ref, instance_name=args.instance)

        per_instance_config_message = (
            instance_configs_messages.CreatePerInstanceConfigMessage)(
                holder,
                instance_ref,
                args.stateful_disk,
                args.stateful_metadata,
                disk_getter=NonExistentDiskGetter())

        operation_ref, service = instance_configs_messages.CallCreateInstances(
            holder=holder,
            igm_ref=igm_ref,
            per_instance_config_message=per_instance_config_message)

        operation_poller = poller.Poller(service)
        create_result = waiter.WaitFor(operation_poller, operation_ref,
                                       'Creating instance.')
        return create_result
Ejemplo n.º 8
0
  def Run(self, args):
    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
    client = holder.client.apitools_client
    messages = holder.client.messages

    disk_ref = self.DISK_ARG.ResolveAsResource(
        args, holder.resources,
        scope_lister=flags.GetDefaultScopeLister(holder.client))
    update_labels, remove_labels = labels_util.GetAndValidateOpsFromArgs(args)

    service = self.GetDisksService(disk_ref, client)
    disk = service.Get(self.GetDiskGetRequest(disk_ref, messages))

    set_labels_request = self.GetLabelsReplacementRequest(
        disk_ref, disk, messages, update_labels, remove_labels)

    if not set_labels_request:
      return disk

    operation = service.SetLabels(set_labels_request)
    operation_ref = holder.resources.Parse(
        operation.selfLink, collection=self.GetOperationCollection(disk_ref))

    operation_poller = poller.Poller(service)
    return waiter.WaitFor(
        operation_poller, operation_ref,
        'Updating labels of disk [{0}]'.format(
            disk_ref.Name()))
def WaitForOperation(resources, service, operation, backend_service_ref,
                     message):
    """Waits for the backend service operation to finish.

  Args:
    resources: The resource parser.
    service: apitools.base.py.base_api.BaseApiService, the service representing
      the target of the operation.
    operation: The operation to wait for.
    backend_service_ref: The backend service reference.
    message: The message to show.

  Returns:
    The operation result.
  """
    params = {'project': backend_service_ref.project}
    if backend_service_ref.Collection() == 'compute.regionBackendServices':
        collection = 'compute.regionOperations'
        params['region'] = backend_service_ref.region
    else:
        collection = 'compute.globalOperations'
    operation_ref = resources.Parse(operation.name,
                                    params=params,
                                    collection=collection)
    operation_poller = poller.Poller(service, backend_service_ref)
    return waiter.WaitFor(operation_poller, operation_ref, message)
  def Update(self, neg_ref, add_endpoints=None, remove_endpoints=None):
    """Updates a Compute Network Endpoint Group."""
    attach_endpoints_ref = None
    detach_endpoints_ref = None

    if add_endpoints:
      operation = self.AttachEndpoints(neg_ref, add_endpoints)
      attach_endpoints_ref = self._GetOperationsRef(operation)

    if remove_endpoints:
      operation = self.DetachEndpoints(neg_ref, remove_endpoints)
      detach_endpoints_ref = self._GetOperationsRef(operation)

    neg_name = neg_ref.Name()
    operation_poller = poller.Poller(self._service)
    result = None
    result = self._WaitForResult(
        operation_poller, attach_endpoints_ref,
        'Attaching {0} endpoints to [{1}].'.format(
            len(add_endpoints) if add_endpoints else 0, neg_name)) or result
    result = self._WaitForResult(
        operation_poller, detach_endpoints_ref,
        'Detaching {0} endpoints from [{1}].'.format(
            len(remove_endpoints) if remove_endpoints else 0, neg_name)
    ) or result

    return result
Ejemplo n.º 11
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        ips_ref = self.IPS_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))

        add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)

        ips_info = api_util.GetInPlaceSnapshotInfo(ips_ref, client, messages)
        ips = ips_info.GetInPlaceSnapshotResource()

        set_label_req = ips_info.GetSetLabelsRequestMessage()
        labels_update = labels_util.Diff(additions=add_labels).Apply(
            set_label_req.LabelsValue, ips.labels)

        request = ips_info.GetSetInPlaceSnapshotLabelsRequestMessage(
            ips, labels_update.GetOrNone())

        if not labels_update.needs_update:
            return ips
        service = ips_info.GetService()
        operation = service.SetLabels(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection=ips_info.GetOperationCollection())

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of in-place snapshot [{0}]'.format(
                ips_ref.Name()))
Ejemplo n.º 12
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        disk_ref = self.DISK_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))

        labels_diff = labels_util.GetAndValidateOpsFromArgs(args)

        disk_info = api_util.GetDiskInfo(disk_ref, client, messages)
        disk = disk_info.GetDiskResource()

        set_label_req = disk_info.GetSetLabelsRequestMessage()
        labels_update = labels_diff.Apply(set_label_req.LabelsValue,
                                          disk.labels)
        request = disk_info.GetSetDiskLabelsRequestMessage(
            disk, labels_update.GetOrNone())

        if not labels_update.needs_update:
            return disk
        service = disk_info.GetService()
        operation = service.SetLabels(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection=disk_info.GetOperationCollection())

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of disk [{0}]'.format(disk_ref.Name()))
Ejemplo n.º 13
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        snapshot_ref = Update.SnapshotArg.ResolveAsResource(
            args, holder.resources)

        labels_diff = labels_util.GetAndValidateOpsFromArgs(args)

        snapshot = client.snapshots.Get(
            messages.ComputeSnapshotsGetRequest(**snapshot_ref.AsDict()))

        labels_update = labels_diff.Apply(
            messages.GlobalSetLabelsRequest.LabelsValue, snapshot.labels)

        if not labels_update.needs_update:
            return snapshot

        request = messages.ComputeSnapshotsSetLabelsRequest(
            project=snapshot_ref.project,
            resource=snapshot_ref.snapshot,
            globalSetLabelsRequest=messages.GlobalSetLabelsRequest(
                labelFingerprint=snapshot.labelFingerprint,
                labels=labels_update.labels))

        operation = client.snapshots.SetLabels(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection='compute.globalOperations')

        operation_poller = poller.Poller(client.snapshots)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of snapshot [{0}]'.format(snapshot_ref.Name()))
    def _Patch(self, pdp_ref, resource):
        """Patches a public delegated prefix resource.

    Args:
      pdp_ref: resource reference.
      resource: PublicDelegatedPrefix resource.

    Returns:
      Operation result from the poller.
    """
        # Drop all fields except fingerprint and modifiable ones.
        resource = self.messages.PublicDelegatedPrefix(
            fingerprint=resource.fingerprint,
            publicDelegatedSubPrefixs=resource.publicDelegatedSubPrefixs)
        include_fields = []
        if not resource.publicDelegatedSubPrefixs:
            include_fields.append('publicDelegatedSubPrefixs')

        is_regional = hasattr(pdp_ref, 'region')

        if is_regional:
            request = self.messages.ComputePublicDelegatedPrefixesPatchRequest(
                publicDelegatedPrefix=pdp_ref.Name(),
                publicDelegatedPrefixResource=resource,
                project=pdp_ref.project,
                region=pdp_ref.region)

            with self.client.apitools_client.IncludeFields(include_fields):
                operation = self._regional_service.Patch(request)
            operation_ref = self.resources.Parse(
                operation.selfLink, collection='compute.regionOperations')
            operation_poller = poller.Poller(self._regional_service)
        else:
            request = self.messages.ComputeGlobalPublicDelegatedPrefixesPatchRequest(
                publicDelegatedPrefix=pdp_ref.Name(),
                publicDelegatedPrefixResource=resource,
                project=pdp_ref.project)

            with self.client.apitools_client.IncludeFields(include_fields):
                operation = self._global_service.Patch(request)
            operation_ref = self.resources.Parse(
                operation.selfLink, collection='compute.globalOperations')
            operation_poller = poller.Poller(self._global_service)

        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating public delegated prefix [{}].'.format(pdp_ref.Name()))
Ejemplo n.º 15
0
  def Run(self, args):
    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
    messages = holder.client.messages
    service = holder.client.apitools_client.networks

    network_ref = self.NETWORK_ARG.ResolveAsResource(args, holder.resources)

    if args.switch_to_custom_subnet_mode:
      prompt_msg = 'Network [{0}] will be switched to custom mode. '.format(
          network_ref.Name()) + 'This operation cannot be undone.'
      console_io.PromptContinue(
          message=prompt_msg, default=True, cancel_on_no=True)
      result = service.SwitchToCustomMode(
          messages.ComputeNetworksSwitchToCustomModeRequest(
              project=network_ref.project, network=network_ref.Name()))
      operation_ref = resources.REGISTRY.Parse(
          result.name,
          params={'project': network_ref.project},
          collection='compute.globalOperations')

      if args.async_:
        log.UpdatedResource(
            operation_ref,
            kind='network {0}'.format(network_ref.Name()),
            is_async=True,
            details='Run the [gcloud compute operations describe] command '
            'to check the status of this operation.')
        return result

      operation_poller = poller.Poller(service, network_ref)
      return waiter.WaitFor(operation_poller, operation_ref,
                            'Switching network to custom-mode')

    network_resource = messages.Network()
    should_patch = False
    if getattr(args, 'mtu', None) is not None:
      network_resource.mtu = args.mtu
      should_patch = True

    if args.bgp_routing_mode or getattr(args, 'multicast_mode', None):
      should_patch = True
      if args.bgp_routing_mode:
        network_resource.routingConfig = messages.NetworkRoutingConfig()
        network_resource.routingConfig.routingMode = (
            messages.NetworkRoutingConfig.RoutingModeValueValuesEnum(
                args.bgp_routing_mode.upper()))
      if getattr(args, 'multicast_mode', None):
        network_resource.multicastMode = (
            messages.Network.MulticastModeValueValuesEnum(
                args.multicast_mode.upper()))

    if should_patch:
      resource = service.Patch(
          messages.ComputeNetworksPatchRequest(
              project=network_ref.project,
              network=network_ref.Name(),
              networkResource=network_resource))

    return resource
Ejemplo n.º 16
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        disk_ref = self.DISK_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))

        add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)

        if disk_ref.Collection() == 'compute.disks':
            service = client.disks
            request_type = messages.ComputeDisksGetRequest
        elif disk_ref.Collection() == 'compute.regionDisks':
            service = client.regionDisks
            request_type = messages.ComputeRegionDisksGetRequest
        else:
            raise ValueError('Unexpected resource argument of {}'.format(
                disk_ref.Collection()))

        disk = service.Get(request_type(**disk_ref.AsDict()))

        if disk_ref.Collection() == 'compute.disks':
            operation_collection = 'compute.zoneOperations'
            labels_update = labels_util.Diff(additions=add_labels).Apply(
                messages.ZoneSetLabelsRequest.LabelsValue, disk.labels)
            request = messages.ComputeDisksSetLabelsRequest(
                project=disk_ref.project,
                resource=disk_ref.disk,
                zone=disk_ref.zone,
                zoneSetLabelsRequest=messages.ZoneSetLabelsRequest(
                    labelFingerprint=disk.labelFingerprint,
                    labels=labels_update.GetOrNone()))
        else:
            operation_collection = 'compute.regionOperations'
            labels_update = labels_util.Diff(additions=add_labels).Apply(
                messages.RegionSetLabelsRequest.LabelsValue, disk.labels)
            request = messages.ComputeRegionDisksSetLabelsRequest(
                project=disk_ref.project,
                resource=disk_ref.disk,
                region=disk_ref.region,
                regionSetLabelsRequest=messages.RegionSetLabelsRequest(
                    labelFingerprint=disk.labelFingerprint,
                    labels=labels_update.GetOrNone()))

        if not labels_update.needs_update:
            return disk

        operation = service.SetLabels(request)
        operation_ref = holder.resources.Parse(operation.selfLink,
                                               collection=operation_collection)

        operation_poller = poller.Poller(service)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating labels of disk [{0}]'.format(disk_ref.Name()))
Ejemplo n.º 17
0
    def Run(self, args):
        """See base.CreateCommand."""

        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()))

        nat = nats_utils.CreateNatMessage(
            args,
            holder,
            with_rules=self.with_rules,
            with_tcp_time_wait_timeout=self.with_tcp_time_wait_timeout)

        replacement.nats.append(nat)

        result = service.Patch(
            messages.ComputeRoutersPatchRequest(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.CreatedResource(
                operation_ref,
                kind='nat [{0}] in router [{1}]'.format(
                    nat.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,
            'Creating NAT [{0}] in router [{1}]'.format(
                nat.name, router_ref.Name()))
    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,
                                      with_private_nat=self.with_private_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))
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client
        resources = holder.resources

        igm_ref = (
            instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
            ResolveAsResource)(
                args,
                resources,
                scope_lister=compute_flags.GetDefaultScopeLister(client),
            )
        instance_ref = self._CreateInstanceReference(
            holder=holder, igm_ref=igm_ref, instance_name=args.instance)

        configs_getter = (instance_configs_getter.
                          InstanceConfigsGetterWithSimpleCache)(client)
        configs_getter.check_if_instance_config_exists(
            igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True)
        per_instance_config = configs_getter.get_instance_config(
            igm_ref=igm_ref, instance_ref=instance_ref)

        self._ValidateStatefulFlagsForInstanceConfigs(args,
                                                      per_instance_config)

        per_instance_config_message = self._CombinePerInstanceConfigMessage(
            holder, per_instance_config, instance_ref, args)

        operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate(
            holder=holder,
            igm_ref=igm_ref,
            per_instance_config_message=per_instance_config_message)

        if igm_ref.Collection() == 'compute.instanceGroupManagers':
            service = holder.client.apitools_client.instanceGroupManagers
        elif igm_ref.Collection() == 'compute.regionInstanceGroupManagers':
            service = holder.client.apitools_client.regionInstanceGroupManagers
        else:
            raise ValueError('Unknown reference type {0}'.format(
                igm_ref.Collection()))

        operation_poller = poller.Poller(service)
        update_result = waiter.WaitFor(operation_poller, operation_ref,
                                       'Updating instance config.')

        if args.update_instance:
            apply_operation_ref = (
                instance_configs_messages.CallApplyUpdatesToInstances)(
                    holder=holder,
                    igm_ref=igm_ref,
                    instances=[six.text_type(instance_ref)],
                    minimal_action=args.instance_update_minimal_action)
            return waiter.WaitFor(operation_poller, apply_operation_ref,
                                  'Applying updates to instances.')

        return update_result
Ejemplo n.º 20
0
  def Run(self, args):
    """Returns a request for moving a disk."""
    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())

    target_disk = Move.disk_arg.ResolveAsResource(
        args, holder.resources,
        scope_lister=flags.GetDefaultScopeLister(holder.client))
    destination_zone = holder.resources.Parse(
        args.destination_zone,
        params={
            'project': properties.VALUES.core.project.GetOrFail,
        },
        collection='compute.zones')

    client = holder.client.apitools_client
    messages = holder.client.messages

    request = messages.ComputeProjectsMoveDiskRequest(
        diskMoveRequest=messages.DiskMoveRequest(
            destinationZone=destination_zone.SelfLink(),
            targetDisk=target_disk.SelfLink(),
        ),
        project=target_disk.project,
    )

    result = client.projects.MoveDisk(request)
    operation_ref = resources.REGISTRY.Parse(
        result.name,
        params={
            'project': properties.VALUES.core.project.GetOrFail,
        },
        collection='compute.globalOperations')

    if args.async:
      log.UpdatedResource(
          operation_ref,
          kind='disk {0}'.format(target_disk.Name()),
          is_async=True,
          details='Run the [gcloud compute operations describe] command '
                  'to check the status of this operation.'
      )
      return result

    destination_disk_ref = holder.resources.Parse(
        target_disk.Name(),
        params={
            'project': destination_zone.project,
            'zone': destination_zone.Name()
        },
        collection='compute.disks')

    operation_poller = poller.Poller(client.disks, destination_disk_ref)

    return waiter.WaitFor(
        operation_poller, operation_ref,
        'Moving disk {0}'.format(target_disk.Name()))
Ejemplo n.º 21
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetInstanceZoneScopeLister(holder.client))

        result = None

        labels_operation_ref = None
        min_cpu_platform_operation_ref = None
        deletion_protection_operation_ref = None
        shielded_vm_config_ref = None

        labels_diff = labels_util.Diff.FromUpdateArgs(args)
        if labels_diff.MayHaveUpdates():
            instance = client.instances.Get(
                messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
            result = instance
            labels_operation_ref = self._GetLabelsOperationRef(
                labels_diff, instance, instance_ref, holder)
        if hasattr(args,
                   'min_cpu_platform') and args.min_cpu_platform is not None:
            min_cpu_platform_operation_ref = self._GetMinCpuPlatformOperationRef(
                args.min_cpu_platform, instance_ref, holder)
        if args.deletion_protection is not None:
            deletion_protection_operation_ref = (
                self._GetDeletionProtectionOperationRef(
                    args.deletion_protection, instance_ref, holder))

        operation_poller = poller.Poller(client.instances)
        result = self._WaitForResult(operation_poller, labels_operation_ref,
                                     'Updating labels of instance [{0}]',
                                     instance_ref.Name()) or result
        result = self._WaitForResult(
            operation_poller, min_cpu_platform_operation_ref,
            'Changing minimum CPU platform of instance [{0}]',
            instance_ref.Name()) or result
        result = self._WaitForResult(
            operation_poller, deletion_protection_operation_ref,
            'Setting deletion protection of instance [{0}] to [{1}]',
            instance_ref.Name(), args.deletion_protection) or result
        if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
            if (hasattr(args, 'shielded_vm_secure_boot')
                    or hasattr(args, 'shielded_vm_vtpm')):
                shielded_vm_config_ref = self._GetShieldedVMConfigRef(
                    instance_ref, args, holder)
                result = self._WaitForResult(
                    operation_poller, shielded_vm_config_ref,
                    'Setting shieldedVMConfig  of instance [{0}]',
                    instance_ref.Name()) or result

        return result
Ejemplo n.º 22
0
 def WaitOperation(self, operation, operation_poller=None, message=None):
   if not operation_poller:
     operation_poller = poller.Poller(
         self._service, self.ref, has_project=self._api_has_project)
   if self._op_has_project and 'projects' not in operation.selfLink:
     operation.selfLink = operation.selfLink.replace('locations',
                                                     'projects/locations')
   operation_ref = self._resources.Parse(
       operation.selfLink, collection=OP_COLLECTION_NAME)
   return waiter.WaitFor(operation_poller, operation_ref, message)
Ejemplo n.º 23
0
    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
        replacement = service.Get(request_type(**router_ref.AsDict()))

        # Retrieve specified NAT and update base fields.
        existing_nat = nats_utils.FindNatOrRaise(replacement, args.name)
        nat = nats_utils.UpdateNatMessage(existing_nat, args, holder,
                                          self.with_private_nat,
                                          self.with_subnet_all)

        request_type = messages.ComputeRoutersPatchRequest
        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='nat [{0}] in router [{1}]'.format(
                    nat.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 nat [{0}] in router [{1}]'.format(
                nat.name, router_ref.Name()))
Ejemplo n.º 24
0
def _StartVm(holder, client, instance_ref):
    """Start the Virtual Machine."""
    operation = client.apitools_client.instances.Start(
        client.messages.ComputeInstancesStartRequest(**instance_ref.AsDict()))

    operation_ref = holder.resources.Parse(operation.selfLink,
                                           collection='compute.zoneOperations')

    operation_poller = poller.Poller(client.apitools_client.instances)
    return waiter.WaitFor(
        operation_poller, operation_ref,
        'Starting instance [{0}]'.format(instance_ref.Name()))
Ejemplo n.º 25
0
    def Run(self, args):
        instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs(
            args, for_update=True)

        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client
        resources = holder.resources

        igm_ref = (
            instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
            ResolveAsResource)(
                args,
                resources,
                scope_lister=compute_flags.GetDefaultScopeLister(client),
            )
        instance_ref = self._CreateInstanceReference(
            holder=holder, igm_ref=igm_ref, instance_name=args.instance)

        configs_getter = (instance_configs_getter.
                          InstanceConfigsGetterWithSimpleCache)(client)
        configs_getter.check_if_instance_config_exists(
            igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True)

        per_instance_config_message = self._CombinePerInstanceConfigMessage(
            holder, configs_getter, igm_ref, instance_ref,
            args.update_stateful_disk, args.remove_stateful_disks,
            args.update_stateful_metadata, args.remove_stateful_metadata)

        operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate(
            holder=holder,
            igm_ref=igm_ref,
            per_instance_config_message=per_instance_config_message)

        if igm_ref.Collection() == 'compute.instanceGroupManagers':
            service = holder.client.apitools_client.instanceGroupManagers
        else:
            service = holder.client.apitools_client.regionInstanceGroupManagers

        operation_poller = poller.Poller(service)
        update_result = waiter.WaitFor(operation_poller, operation_ref,
                                       'Updating instance config.')

        if args.force_instance_update:
            apply_operation_ref = (
                instance_configs_messages.CallApplyUpdatesToInstances)(
                    holder=holder,
                    igm_ref=igm_ref,
                    instances=[str(instance_ref)])
            return waiter.WaitFor(operation_poller, apply_operation_ref,
                                  'Applying updates to instances.')

        return update_result
Ejemplo n.º 26
0
def UpdateInstance(holder,
                   client,
                   instance_ref,
                   instance,
                   args,
                   container_mount_disk_enabled=False,
                   container_mount_disk=None):
    """Update an instance and its container metadata."""
    operation_poller = poller.Poller(client.apitools_client.instances)

    result = _UpdateShieldedInstanceConfig(holder, client, operation_poller,
                                           instance_ref, args)

    result = _SetShieldedInstanceIntegrityPolicy(
        holder, client, operation_poller, instance_ref, args) or result

    # find gce-container-declaration metadata entry
    for metadata in instance.metadata.items:
        if metadata.key == GCE_CONTAINER_DECLARATION:
            UpdateMetadata(
                holder,
                metadata,
                args,
                instance,
                container_mount_disk_enabled=container_mount_disk_enabled,
                container_mount_disk=container_mount_disk)

            # update Google Compute Engine resource
            operation = client.apitools_client.instances.SetMetadata(
                client.messages.ComputeInstancesSetMetadataRequest(
                    metadata=instance.metadata, **instance_ref.AsDict()))

            operation_ref = holder.resources.Parse(
                operation.selfLink, collection='compute.zoneOperations')

            set_metadata_waiter = waiter.WaitFor(
                operation_poller, operation_ref,
                'Updating specification of container [{0}]'.format(
                    instance_ref.Name()))

            if (instance.status ==
                    client.messages.Instance.StatusValueValuesEnum.TERMINATED):
                return set_metadata_waiter or result
            elif (instance.status ==
                  client.messages.Instance.StatusValueValuesEnum.SUSPENDED):
                return _StopVm(holder, client, instance_ref) or result
            else:
                _StopVm(holder, client, instance_ref)
                return _StartVm(holder, client, instance_ref) or result

    raise NoGceContainerDeclarationMetadataKey()
Ejemplo n.º 27
0
  def Run(self, args):
    """Issues API requests to update a Target VPN Gateway.

    Args:
      args: argparse.Namespace, The arguments received by this command.
    Returns:
      [protorpc.messages.Message], A list of responses returned
      by the compute API.
    """
    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
    client = holder.client.apitools_client
    messages = holder.client.messages

    target_vpn_gateway_ref = self.TARGET_VPN_GATEWAY_ARG.ResolveAsResource(
        args,
        holder.resources,
        scope_lister=compute_flags.GetDefaultScopeLister(holder.client))

    update_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
    remove_labels = labels_util.GetRemoveLabelsListFromArgs(args)
    if update_labels is None and remove_labels is None:
      raise calliope_exceptions.RequiredArgumentException(
          'LABELS', 'At least one of --update-labels or '
          '--remove-labels must be specified.')

    target_vpn_gateway = client.targetVpnGateways.Get(
        messages.ComputeTargetVpnGatewaysGetRequest(
            **target_vpn_gateway_ref.AsDict()))
    labels_value = messages.RegionSetLabelsRequest.LabelsValue

    replacement = labels_util.UpdateLabels(
        target_vpn_gateway.labels,
        labels_value,
        update_labels=update_labels,
        remove_labels=remove_labels)

    if not replacement:
      return target_vpn_gateway

    request = self._CreateRegionalSetLabelsRequest(
        messages, target_vpn_gateway_ref, target_vpn_gateway, replacement)

    operation = client.targetVpnGateways.SetLabels(request)
    operation_ref = holder.resources.Parse(
        operation.selfLink, collection='compute.regionOperations')

    operation_poller = poller.Poller(client.targetVpnGateways)

    return waiter.WaitFor(operation_poller, operation_ref,
                          'Updating labels of target VPN gateway [{0}]'.format(
                              target_vpn_gateway_ref.Name()))
Ejemplo n.º 28
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        target_instance = flags.INSTANCE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetInstanceZoneScopeLister(holder.client))
        destination_zone = holder.resources.Parse(
            args.destination_zone,
            params={'project': target_instance.project},
            collection='compute.zones')

        client = holder.client.apitools_client
        messages = holder.client.messages

        request = messages.ComputeProjectsMoveInstanceRequest(
            instanceMoveRequest=messages.InstanceMoveRequest(
                destinationZone=destination_zone.SelfLink(),
                targetInstance=target_instance.SelfLink(),
            ),
            project=target_instance.project,
        )

        result = client.projects.MoveInstance(request)
        operation_ref = resources.REGISTRY.Parse(
            result.name,
            params={'project': target_instance.project},
            collection='compute.globalOperations')

        if args.async_:
            log.UpdatedResource(
                operation_ref,
                kind='gce instance {0}'.format(target_instance.Name()),
                is_async=True,
                details='Use [gcloud compute operations describe] command '
                'to check the status of this operation.')
            return result

        destination_instance_ref = holder.resources.Parse(
            target_instance.Name(),
            collection='compute.instances',
            params={
                'project': target_instance.project,
                'zone': destination_zone.Name()
            })

        operation_poller = poller.Poller(client.instances,
                                         destination_instance_ref)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Moving gce instance {0}'.format(target_instance.Name()))
Ejemplo n.º 29
0
    def Run(self, args):
        holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
        client = holder.client.apitools_client
        messages = holder.client.messages

        instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource(
            args,
            holder.resources,
            scope_lister=flags.GetDefaultScopeLister(holder.client))

        instance = client.instances.Get(
            messages.ComputeInstancesGetRequest(**instance_ref.AsDict()))
        for i in instance.networkInterfaces:
            if i.name == args.network_interface:
                fingerprint = i.fingerprint
                break
        else:
            raise exceptions.UnknownArgumentException(
                'network-interface',
                'Instance does not have a network interface [{}], '
                'present interfaces are [{}].'.format(
                    args.network_interface,
                    ', '.join([i.name for i in instance.networkInterfaces])))

        patch_network_interface = messages.NetworkInterface(
            aliasIpRanges=(
                alias_ip_range_utils.CreateAliasIpRangeMessagesFromString(
                    messages, True, args.aliases)),
            fingerprint=fingerprint)

        request = messages.ComputeInstancesUpdateNetworkInterfaceRequest(
            project=instance_ref.project,
            instance=instance_ref.instance,
            zone=instance_ref.zone,
            networkInterface=args.network_interface,
            networkInterfaceResource=patch_network_interface)

        cleared_fields = []
        if not patch_network_interface.aliasIpRanges:
            cleared_fields.append('aliasIpRanges')
        with client.IncludeFields(cleared_fields):
            operation = client.instances.UpdateNetworkInterface(request)
        operation_ref = holder.resources.Parse(
            operation.selfLink, collection='compute.zoneOperations')

        operation_poller = poller.Poller(client.instances)
        return waiter.WaitFor(
            operation_poller, operation_ref,
            'Updating network interface [{0}] of instance [{1}]'.format(
                args.network_interface, instance_ref.Name()))
    def WaitForOperation(self, ssl_policy_ref, operation_ref, wait_message):
        """Waits for the specified operation to complete and returns the target.

    Args:
      ssl_policy_ref: The SSL policy reference object.
      operation_ref: The operation reference object to wait for.
      wait_message: String representing the wait message to display while the
          operation is in progress.

    Returns:
      The resulting resource object after the operation completes.
    """
        operation_poller = poller.Poller(self._service, ssl_policy_ref)
        return waiter.WaitFor(operation_poller, operation_ref, wait_message)