Struct TagKeys

pub struct TagKeys { /* private fields */ }

Implements a client for the Cloud Resource Manager API.

Service Description

Allow users to create and manage tag keys.

Configuration

TagKeys has various configuration parameters, the defaults should work with most applications.

Pooling and Cloning

TagKeys holds a connection pool internally, it is advised to create one and the reuse it. You do not need to wrap TagKeys in an Rc or Arc to reuse it, because it already uses an Arc internally.

Implementations

impl TagKeys

pub async fn new() -> Result<Self>

Creates a new client with the default configuration.

pub async fn new_with_config(conf: ClientConfig) -> Result<Self>

Creates a new client with the specified configuration.

pub fn from_stub<T>(stub: T) -> Self

where T: TagKeys + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is when mocking the client.

pub fn list_tag_keys(&self) -> ListTagKeys

Lists all TagKeys for a parent resource.

pub fn get_tag_key(&self, name: impl Into<String>) -> GetTagKey

Retrieves a TagKey. This method will return PERMISSION_DENIED if the key does not exist or the user does not have permission to view it.

pub fn get_namespaced_tag_key(&self) -> GetNamespacedTagKey

Retrieves a TagKey by its namespaced name. This method will return PERMISSION_DENIED if the key does not exist or the user does not have permission to view it.

pub fn create_tag_key(&self) -> CreateTagKey

Creates a new TagKey. If another request with the same parameters is sent while the original request is in process, the second request will receive an error. A maximum of 1000 TagKeys can exist under a parent at any given time.

Long running operations

Calling poller() on the resulting builder returns an implementation of the lro::Poller trait. You need to call Poller::poll on this Poller at least once to start the LRO. You may periodically poll this object to find the status of the operation. The poller automatically extract the final response value and any intermediate metadata values.

Calling send() on the resulting builder starts a LRO (long-Running Operation). LROs run in the background, and the application may poll them periodically to find out if they have succeeded, or failed. See below for instructions on how to manually use the resulting Operation. We recommend poller() in favor of send().

Polling until completion

Applications that do not care about intermediate results in a long-running operation may use the until_done() function:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::CreateTagKeyMetadata>
) -> Result<model::TagKey> {
    poller.until_done().await
}

This will wait until the LRO completes (successfully or with an error). Applications can set the PollingPolicy and PollingBackoffPolicy to control for how long the function runs.

Polling with detailed metadata updates

Using the result of poller() follows a common pattern:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::CreateTagKeyMetadata>
) -> Result<model::TagKey> {
    while let Some(p) = poller.poll().await {
        match p {
            lro::PollingResult::Completed(r) => { return r; },
            lro::PollingResult::InProgress(m) => { println!("in progress {m:?}"); },
            lro::PollingResult::PollingError(_) => { /* ignored */ },
        }
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
    Err(gax::error::Error::other("LRO never completed"))
}

Manually polling long-running operations

If you call send(), you need to examine the contents of the resulting Operation to determine the result of the operation.

If the done field is true, the operation has completed. The result field contains the final response, this will be a crate::model::TagKey (as an Any), or the error (as a Status).

If the done field is false, the operation has not completed. The operation may also include a crate::model::CreateTagKeyMetadata value in the metadata field. This value would also be encoded as an Any. The metadata may include information about how much progress the LRO has made.

To find out if the operation has completed, use the get_operation method and repeat the steps outlined above.

Note that most errors on get_operation do not indicate that the long-running operation failed. Long-running operation failures return the error status in the result field.

pub fn update_tag_key(&self, tag_key: impl Into<TagKey>) -> UpdateTagKey

Updates the attributes of the TagKey resource.

Long running operations

Calling poller() on the resulting builder returns an implementation of the lro::Poller trait. You need to call Poller::poll on this Poller at least once to start the LRO. You may periodically poll this object to find the status of the operation. The poller automatically extract the final response value and any intermediate metadata values.

Calling send() on the resulting builder starts a LRO (long-Running Operation). LROs run in the background, and the application may poll them periodically to find out if they have succeeded, or failed. See below for instructions on how to manually use the resulting Operation. We recommend poller() in favor of send().

Polling until completion

Applications that do not care about intermediate results in a long-running operation may use the until_done() function:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::UpdateTagKeyMetadata>
) -> Result<model::TagKey> {
    poller.until_done().await
}

This will wait until the LRO completes (successfully or with an error). Applications can set the PollingPolicy and PollingBackoffPolicy to control for how long the function runs.

Polling with detailed metadata updates

Using the result of poller() follows a common pattern:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::UpdateTagKeyMetadata>
) -> Result<model::TagKey> {
    while let Some(p) = poller.poll().await {
        match p {
            lro::PollingResult::Completed(r) => { return r; },
            lro::PollingResult::InProgress(m) => { println!("in progress {m:?}"); },
            lro::PollingResult::PollingError(_) => { /* ignored */ },
        }
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
    Err(gax::error::Error::other("LRO never completed"))
}

Manually polling long-running operations

If you call send(), you need to examine the contents of the resulting Operation to determine the result of the operation.

If the done field is true, the operation has completed. The result field contains the final response, this will be a crate::model::TagKey (as an Any), or the error (as a Status).

If the done field is false, the operation has not completed. The operation may also include a crate::model::UpdateTagKeyMetadata value in the metadata field. This value would also be encoded as an Any. The metadata may include information about how much progress the LRO has made.

To find out if the operation has completed, use the get_operation method and repeat the steps outlined above.

Note that most errors on get_operation do not indicate that the long-running operation failed. Long-running operation failures return the error status in the result field.

pub fn delete_tag_key(&self, name: impl Into<String>) -> DeleteTagKey

Deletes a TagKey. The TagKey cannot be deleted if it has any child TagValues.

Long running operations

Calling poller() on the resulting builder returns an implementation of the lro::Poller trait. You need to call Poller::poll on this Poller at least once to start the LRO. You may periodically poll this object to find the status of the operation. The poller automatically extract the final response value and any intermediate metadata values.

Calling send() on the resulting builder starts a LRO (long-Running Operation). LROs run in the background, and the application may poll them periodically to find out if they have succeeded, or failed. See below for instructions on how to manually use the resulting Operation. We recommend poller() in favor of send().

Polling until completion

Applications that do not care about intermediate results in a long-running operation may use the until_done() function:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::DeleteTagKeyMetadata>
) -> Result<model::TagKey> {
    poller.until_done().await
}

This will wait until the LRO completes (successfully or with an error). Applications can set the PollingPolicy and PollingBackoffPolicy to control for how long the function runs.

Polling with detailed metadata updates

Using the result of poller() follows a common pattern:

async fn wait(
    mut poller: impl lro::Poller<model::TagKey, model::DeleteTagKeyMetadata>
) -> Result<model::TagKey> {
    while let Some(p) = poller.poll().await {
        match p {
            lro::PollingResult::Completed(r) => { return r; },
            lro::PollingResult::InProgress(m) => { println!("in progress {m:?}"); },
            lro::PollingResult::PollingError(_) => { /* ignored */ },
        }
        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    }
    Err(gax::error::Error::other("LRO never completed"))
}

Manually polling long-running operations

If you call send(), you need to examine the contents of the resulting Operation to determine the result of the operation.

If the done field is true, the operation has completed. The result field contains the final response, this will be a crate::model::TagKey (as an Any), or the error (as a Status).

If the done field is false, the operation has not completed. The operation may also include a crate::model::DeleteTagKeyMetadata value in the metadata field. This value would also be encoded as an Any. The metadata may include information about how much progress the LRO has made.

To find out if the operation has completed, use the get_operation method and repeat the steps outlined above.

Note that most errors on get_operation do not indicate that the long-running operation failed. Long-running operation failures return the error status in the result field.

pub fn get_iam_policy(&self, resource: impl Into<String>) -> GetIamPolicy

Gets the access control policy for a TagKey. The returned policy may be empty if no such policy or resource exists. The resource field should be the TagKey’s resource name. For example, “tagKeys/1234”. The caller must have cloudresourcemanager.googleapis.com/tagKeys.getIamPolicy permission on the specified TagKey.

pub fn set_iam_policy(&self, resource: impl Into<String>) -> SetIamPolicy

Sets the access control policy on a TagKey, replacing any existing policy. The resource field should be the TagKey’s resource name. For example, “tagKeys/1234”. The caller must have resourcemanager.tagKeys.setIamPolicy permission on the identified tagValue.

pub fn test_iam_permissions( &self, resource: impl Into<String>, ) -> TestIamPermissions

Returns permissions that a caller has on the specified TagKey. The resource field should be the TagKey’s resource name. For example, “tagKeys/1234”.

There are no permissions required for making this API call.

pub fn get_operation(&self, name: impl Into<String>) -> GetOperation

Provides the Operations service functionality in this service.

Trait Implementations

impl Clone for TagKeys

fn clone(&self) -> TagKeys

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TagKeys

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.