Struct NetApp 

pub struct NetApp { /* private fields */ }

Implements a client for the NetApp API.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
async fn sample(
   project_id: &str,
   location_id: &str,
) -> anyhow::Result<()> {
    let client = NetApp::builder().build().await?;
    let mut list = client.list_storage_pools()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

Service Description

NetApp Files Google Cloud Service

Configuration

To configure NetApp use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://netapp.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

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

Implementations

impl NetApp

pub fn builder() -> ClientBuilder

Returns a builder for NetApp.

let client = NetApp::builder().build().await?;

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

where T: NetApp + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is in tests mocking the client’s behavior.

pub fn list_storage_pools(&self) -> ListStoragePools

Returns descriptions of all storage pools owned by the caller.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_storage_pools()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn create_storage_pool(&self) -> CreateStoragePool

Creates a new storage pool.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::StoragePool;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_storage_pool()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_storage_pool(
            StoragePool::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_storage_pool(&self) -> GetStoragePool

Returns the description of the specified storage pool by poolId.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, storage_pool_id: &str
) -> Result<()> {
    let response = client.get_storage_pool()
        .set_name(format!("projects/{project_id}/locations/{location_id}/storagePools/{storage_pool_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_storage_pool(&self) -> UpdateStoragePool

Updates the storage pool properties with the full spec

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::StoragePool;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, storage_pool_id: &str
) -> Result<()> {
    let response = client.update_storage_pool()
        .set_storage_pool(
            StoragePool::new().set_name(format!("projects/{project_id}/locations/{location_id}/storagePools/{storage_pool_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_storage_pool(&self) -> DeleteStoragePool

Warning! This operation will permanently delete the storage pool.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, storage_pool_id: &str
) -> Result<()> {
    client.delete_storage_pool()
        .set_name(format!("projects/{project_id}/locations/{location_id}/storagePools/{storage_pool_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn validate_directory_service(&self) -> ValidateDirectoryService

ValidateDirectoryService does a connectivity check for a directory service policy attached to the storage pool.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    client.validate_directory_service()
        /* set fields */
        .poller().until_done().await?;
    Ok(())
}

pub fn switch_active_replica_zone(&self) -> SwitchActiveReplicaZone

This operation will switch the active/replica zone for a regional storagePool.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.switch_active_replica_zone()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_volumes(&self) -> ListVolumes

Lists Volumes in a given project.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_volumes()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_volume(&self) -> GetVolume

Gets details of a single Volume.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let response = client.get_volume()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_volume(&self) -> CreateVolume

Creates a new Volume in a given project and location.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::Volume;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_volume()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_volume_id("volume_id_value")
        .set_volume(
            Volume::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_volume(&self) -> UpdateVolume

Updates the parameters of a single Volume.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::Volume;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let response = client.update_volume()
        .set_volume(
            Volume::new().set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_volume(&self) -> DeleteVolume

Deletes a single Volume.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    client.delete_volume()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn revert_volume(&self) -> RevertVolume

Revert an existing volume to a specified snapshot. Warning! This operation will permanently revert all changes made after the snapshot was created.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.revert_volume()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn establish_volume_peering(&self) -> EstablishVolumePeering

Establish volume peering. This is used to establish cluster and svm peerings between the GCNV and OnPrem clusters.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.establish_volume_peering()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_snapshots(&self) -> ListSnapshots

Returns descriptions of all snapshots for a volume.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let mut list = client.list_snapshots()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_snapshot(&self) -> GetSnapshot

Describe a snapshot for a volume.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, snapshot_id: &str
) -> Result<()> {
    let response = client.get_snapshot()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/snapshots/{snapshot_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_snapshot(&self) -> CreateSnapshot

Create a new snapshot for a volume.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::Snapshot;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let response = client.create_snapshot()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .set_snapshot_id("snapshot_id_value")
        .set_snapshot(
            Snapshot::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_snapshot(&self) -> DeleteSnapshot

Deletes a snapshot.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, snapshot_id: &str
) -> Result<()> {
    client.delete_snapshot()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/snapshots/{snapshot_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn update_snapshot(&self) -> UpdateSnapshot

Updates the settings of a specific snapshot.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::Snapshot;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, snapshot_id: &str
) -> Result<()> {
    let response = client.update_snapshot()
        .set_snapshot(
            Snapshot::new().set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/snapshots/{snapshot_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_active_directories(&self) -> ListActiveDirectories

Lists active directories.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_active_directories()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_active_directory(&self) -> GetActiveDirectory

Describes a specified active directory.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, active_directory_id: &str
) -> Result<()> {
    let response = client.get_active_directory()
        .set_name(format!("projects/{project_id}/locations/{location_id}/activeDirectories/{active_directory_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_active_directory(&self) -> CreateActiveDirectory

CreateActiveDirectory Creates the active directory specified in the request.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::ActiveDirectory;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_active_directory()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_active_directory(
            ActiveDirectory::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_active_directory(&self) -> UpdateActiveDirectory

Update the parameters of an active directories.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::ActiveDirectory;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, active_directory_id: &str
) -> Result<()> {
    let response = client.update_active_directory()
        .set_active_directory(
            ActiveDirectory::new().set_name(format!("projects/{project_id}/locations/{location_id}/activeDirectories/{active_directory_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_active_directory(&self) -> DeleteActiveDirectory

Delete the active directory specified in the request.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, active_directory_id: &str
) -> Result<()> {
    client.delete_active_directory()
        .set_name(format!("projects/{project_id}/locations/{location_id}/activeDirectories/{active_directory_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn list_kms_configs(&self) -> ListKmsConfigs

Returns descriptions of all KMS configs owned by the caller.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_kms_configs()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn create_kms_config(&self) -> CreateKmsConfig

Creates a new KMS config.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::KmsConfig;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_kms_config()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_kms_config(
            KmsConfig::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_kms_config(&self) -> GetKmsConfig

Returns the description of the specified KMS config by kms_config_id.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, kms_config_id: &str
) -> Result<()> {
    let response = client.get_kms_config()
        .set_name(format!("projects/{project_id}/locations/{location_id}/kmsConfigs/{kms_config_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_kms_config(&self) -> UpdateKmsConfig

Updates the Kms config properties with the full spec

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::KmsConfig;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, kms_config_id: &str
) -> Result<()> {
    let response = client.update_kms_config()
        .set_kms_config(
            KmsConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/kmsConfigs/{kms_config_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn encrypt_volumes(&self) -> EncryptVolumes

Encrypt the existing volumes without CMEK encryption with the desired the KMS config for the whole region.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.encrypt_volumes()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn verify_kms_config(&self) -> VerifyKmsConfig

Verifies KMS config reachability.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.verify_kms_config()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_kms_config(&self) -> DeleteKmsConfig

Warning! This operation will permanently delete the Kms config.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, kms_config_id: &str
) -> Result<()> {
    client.delete_kms_config()
        .set_name(format!("projects/{project_id}/locations/{location_id}/kmsConfigs/{kms_config_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn list_replications(&self) -> ListReplications

Returns descriptions of all replications for a volume.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let mut list = client.list_replications()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_replication(&self) -> GetReplication

Describe a replication for a volume.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, replication_id: &str
) -> Result<()> {
    let response = client.get_replication()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/replications/{replication_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_replication(&self) -> CreateReplication

Create a new replication for a volume.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::Replication;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let response = client.create_replication()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .set_replication_id("replication_id_value")
        .set_replication(
            Replication::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_replication(&self) -> DeleteReplication

Deletes a replication.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, replication_id: &str
) -> Result<()> {
    client.delete_replication()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/replications/{replication_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn update_replication(&self) -> UpdateReplication

Updates the settings of a specific replication.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::Replication;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, replication_id: &str
) -> Result<()> {
    let response = client.update_replication()
        .set_replication(
            Replication::new().set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/replications/{replication_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn stop_replication(&self) -> StopReplication

Stop Cross Region Replication.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.stop_replication()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn resume_replication(&self) -> ResumeReplication

Resume Cross Region Replication.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.resume_replication()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn reverse_replication_direction(&self) -> ReverseReplicationDirection

Reverses direction of replication. Source becomes destination and destination becomes source.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.reverse_replication_direction()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn establish_peering(&self) -> EstablishPeering

Establish replication peering.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.establish_peering()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn sync_replication(&self) -> SyncReplication

Syncs the replication. This will invoke one time volume data transfer from source to destination.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.sync_replication()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_backup_vault(&self) -> CreateBackupVault

Creates new backup vault

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::BackupVault;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_backup_vault()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_backup_vault(
            BackupVault::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_backup_vault(&self) -> GetBackupVault

Returns the description of the specified backup vault

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str
) -> Result<()> {
    let response = client.get_backup_vault()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_backup_vaults(&self) -> ListBackupVaults

Returns list of all available backup vaults.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_backup_vaults()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn update_backup_vault(&self) -> UpdateBackupVault

Updates the settings of a specific backup vault.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::BackupVault;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str
) -> Result<()> {
    let response = client.update_backup_vault()
        .set_backup_vault(
            BackupVault::new().set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_backup_vault(&self) -> DeleteBackupVault

Warning! This operation will permanently delete the backup vault.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str
) -> Result<()> {
    client.delete_backup_vault()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn create_backup(&self) -> CreateBackup

Creates a backup from the volume specified in the request The backup can be created from the given snapshot if specified in the request. If no snapshot specified, there’ll be a new snapshot taken to initiate the backup creation.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::Backup;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str
) -> Result<()> {
    let response = client.create_backup()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}"))
        .set_backup_id("backup_id_value")
        .set_backup(
            Backup::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_backup(&self) -> GetBackup

Returns the description of the specified backup

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str, backup_id: &str
) -> Result<()> {
    let response = client.get_backup()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}/backups/{backup_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_backups(&self) -> ListBackups

Returns descriptions of all backups for a backupVault.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str
) -> Result<()> {
    let mut list = client.list_backups()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn delete_backup(&self) -> DeleteBackup

Warning! This operation will permanently delete the backup.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str, backup_id: &str
) -> Result<()> {
    client.delete_backup()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}/backups/{backup_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn update_backup(&self) -> UpdateBackup

Update backup with full spec.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::Backup;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_vault_id: &str, backup_id: &str
) -> Result<()> {
    let response = client.update_backup()
        .set_backup(
            Backup::new().set_name(format!("projects/{project_id}/locations/{location_id}/backupVaults/{backup_vault_id}/backups/{backup_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_backup_policy(&self) -> CreateBackupPolicy

Creates new backup policy

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::BackupPolicy;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_backup_policy()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_backup_policy(
            BackupPolicy::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_backup_policy(&self) -> GetBackupPolicy

Returns the description of the specified backup policy by backup_policy_id.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_policy_id: &str
) -> Result<()> {
    let response = client.get_backup_policy()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupPolicies/{backup_policy_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_backup_policies(&self) -> ListBackupPolicies

Returns list of all available backup policies.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_backup_policies()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn update_backup_policy(&self) -> UpdateBackupPolicy

Updates settings of a specific backup policy.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::BackupPolicy;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_policy_id: &str
) -> Result<()> {
    let response = client.update_backup_policy()
        .set_backup_policy(
            BackupPolicy::new().set_name(format!("projects/{project_id}/locations/{location_id}/backupPolicies/{backup_policy_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_backup_policy(&self) -> DeleteBackupPolicy

Warning! This operation will permanently delete the backup policy.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, backup_policy_id: &str
) -> Result<()> {
    client.delete_backup_policy()
        .set_name(format!("projects/{project_id}/locations/{location_id}/backupPolicies/{backup_policy_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn list_quota_rules(&self) -> ListQuotaRules

Returns list of all quota rules in a location.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let mut list = client.list_quota_rules()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_quota_rule(&self) -> GetQuotaRule

Returns details of the specified quota rule.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, quota_rule_id: &str
) -> Result<()> {
    let response = client.get_quota_rule()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/quotaRules/{quota_rule_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_quota_rule(&self) -> CreateQuotaRule

Creates a new quota rule.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::QuotaRule;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str
) -> Result<()> {
    let response = client.create_quota_rule()
        .set_parent(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}"))
        .set_quota_rule(
            QuotaRule::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_quota_rule(&self) -> UpdateQuotaRule

Updates a quota rule.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::QuotaRule;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, quota_rule_id: &str
) -> Result<()> {
    let response = client.update_quota_rule()
        .set_quota_rule(
            QuotaRule::new().set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/quotaRules/{quota_rule_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_quota_rule(&self) -> DeleteQuotaRule

Deletes a quota rule.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, volume_id: &str, quota_rule_id: &str
) -> Result<()> {
    client.delete_quota_rule()
        .set_name(format!("projects/{project_id}/locations/{location_id}/volumes/{volume_id}/quotaRules/{quota_rule_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn restore_backup_files(&self) -> RestoreBackupFiles

Restore files from a backup to a volume.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.restore_backup_files()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_host_groups(&self) -> ListHostGroups

Returns a list of host groups in a location. Use - as location to list host groups across all locations.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let mut list = client.list_host_groups()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_host_group(&self) -> GetHostGroup

Returns details of the specified host group.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, host_group_id: &str
) -> Result<()> {
    let response = client.get_host_group()
        .set_name(format!("projects/{project_id}/locations/{location_id}/hostGroups/{host_group_id}"))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn create_host_group(&self) -> CreateHostGroup

Creates a new host group.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::model::HostGroup;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str
) -> Result<()> {
    let response = client.create_host_group()
        .set_parent(format!("projects/{project_id}/locations/{location_id}"))
        .set_host_group(
            HostGroup::new()/* set fields */
        )
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn update_host_group(&self) -> UpdateHostGroup

Updates an existing host group.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_wkt::FieldMask;
use google_cloud_netapp_v1::model::HostGroup;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, host_group_id: &str
) -> Result<()> {
    let response = client.update_host_group()
        .set_host_group(
            HostGroup::new().set_name(format!("projects/{project_id}/locations/{location_id}/hostGroups/{host_group_id}"))/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_host_group(&self) -> DeleteHostGroup

Deletes a host group.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp, project_id: &str, location_id: &str, host_group_id: &str
) -> Result<()> {
    client.delete_host_group()
        .set_name(format!("projects/{project_id}/locations/{location_id}/hostGroups/{host_group_id}"))
        .poller().until_done().await?;
    Ok(())
}

pub fn execute_ontap_post(&self) -> ExecuteOntapPost

ExecuteOntapPost dispatches the ONTAP POST request to the StoragePool cluster.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.execute_ontap_post()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn execute_ontap_get(&self) -> ExecuteOntapGet

ExecuteOntapGet dispatches the ONTAP GET request to the StoragePool cluster.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.execute_ontap_get()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn execute_ontap_delete(&self) -> ExecuteOntapDelete

ExecuteOntapDelete dispatches the ONTAP DELETE request to the StoragePool cluster.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.execute_ontap_delete()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn execute_ontap_patch(&self) -> ExecuteOntapPatch

ExecuteOntapPatch dispatches the ONTAP PATCH request to the StoragePool cluster.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.execute_ontap_patch()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_locations(&self) -> ListLocations

Lists information about the supported locations for this service.

This method lists locations based on the resource scope provided in the ListLocationsRequest.name field: * Global locations: If name is empty, the method lists the public locations available to all projects. * Project-specific locations: If name follows the format projects/{project}, the method lists locations visible to that specific project. This includes public, private, or other project-specific locations enabled for the project.

For gRPC and client library implementations, the resource name is passed as the name field. For direct service calls, the resource name is incorporated into the request path based on the specific service implementation and version.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let mut list = client.list_locations()
        /* set fields */
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_location(&self) -> GetLocation

Gets information about a location.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.get_location()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_operations(&self) -> ListOperations

Provides the Operations service functionality in this service.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let mut list = client.list_operations()
        /* set fields */
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_operation(&self) -> GetOperation

Provides the Operations service functionality in this service.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    let response = client.get_operation()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_operation(&self) -> DeleteOperation

Provides the Operations service functionality in this service.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    client.delete_operation()
        /* set fields */
        .send().await?;
    Ok(())
}

pub fn cancel_operation(&self) -> CancelOperation

Provides the Operations service functionality in this service.

Example

use google_cloud_netapp_v1::Result;
async fn sample(
   client: &NetApp
) -> Result<()> {
    client.cancel_operation()
        /* set fields */
        .send().await?;
    Ok(())
}

Trait Implementations

impl Clone for NetApp

fn clone(&self) -> NetApp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NetApp

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

Formats the value using the given formatter.