diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/_azure_net_app_files_management_client.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/_azure_net_app_files_management_client.py index bcdf17ef4942..30d82064bb7d 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/_azure_net_app_files_management_client.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/_azure_net_app_files_management_client.py @@ -19,6 +19,11 @@ from .operations import PoolsOperations from .operations import VolumesOperations from .operations import SnapshotsOperations +from .operations import SnapshotPoliciesOperations +from .operations import AccountBackupsOperations +from .operations import BackupsOperations +from .operations import BackupPoliciesOperations +from .operations import VaultsOperations from . import models @@ -40,6 +45,16 @@ class AzureNetAppFilesManagementClient(SDKClient): :vartype volumes: azure.mgmt.netapp.operations.VolumesOperations :ivar snapshots: Snapshots operations :vartype snapshots: azure.mgmt.netapp.operations.SnapshotsOperations + :ivar snapshot_policies: SnapshotPolicies operations + :vartype snapshot_policies: azure.mgmt.netapp.operations.SnapshotPoliciesOperations + :ivar account_backups: AccountBackups operations + :vartype account_backups: azure.mgmt.netapp.operations.AccountBackupsOperations + :ivar backups: Backups operations + :vartype backups: azure.mgmt.netapp.operations.BackupsOperations + :ivar backup_policies: BackupPolicies operations + :vartype backup_policies: azure.mgmt.netapp.operations.BackupPoliciesOperations + :ivar vaults: Vaults operations + :vartype vaults: azure.mgmt.netapp.operations.VaultsOperations :param credentials: Credentials needed for the client to connect to Azure. :type credentials: :mod:`A msrestazure Credentials @@ -58,7 +73,7 @@ def __init__( super(AzureNetAppFilesManagementClient, self).__init__(self.config.credentials, self.config) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} - self.api_version = '2020-02-01' + self.api_version = '2020-06-01' self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) @@ -74,3 +89,13 @@ def __init__( self._client, self.config, self._serialize, self._deserialize) self.snapshots = SnapshotsOperations( self._client, self.config, self._serialize, self._deserialize) + self.snapshot_policies = SnapshotPoliciesOperations( + self._client, self.config, self._serialize, self._deserialize) + self.account_backups = AccountBackupsOperations( + self._client, self.config, self._serialize, self._deserialize) + self.backups = BackupsOperations( + self._client, self.config, self._serialize, self._deserialize) + self.backup_policies = BackupPoliciesOperations( + self._client, self.config, self._serialize, self._deserialize) + self.vaults = VaultsOperations( + self._client, self.config, self._serialize, self._deserialize) diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/__init__.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/__init__.py index dd213c562680..ad20b7b9e5b6 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/__init__.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/__init__.py @@ -12,68 +12,118 @@ try: from ._models_py3 import ActiveDirectory from ._models_py3 import AuthorizeRequest + from ._models_py3 import Backup + from ._models_py3 import BackupPatch + from ._models_py3 import BackupPolicy + from ._models_py3 import BackupPolicyDetails + from ._models_py3 import BackupPolicyPatch + from ._models_py3 import BackupsList + from ._models_py3 import BreakReplicationRequest from ._models_py3 import CapacityPool from ._models_py3 import CapacityPoolPatch + from ._models_py3 import CheckAvailabilityResponse + from ._models_py3 import DailySchedule from ._models_py3 import Dimension from ._models_py3 import ExportPolicyRule + from ._models_py3 import HourlySchedule from ._models_py3 import MetricSpecification + from ._models_py3 import MonthlySchedule from ._models_py3 import MountTarget from ._models_py3 import MountTargetProperties from ._models_py3 import NetAppAccount from ._models_py3 import NetAppAccountPatch from ._models_py3 import Operation from ._models_py3 import OperationDisplay + from ._models_py3 import PoolChangeRequest + from ._models_py3 import QuotaAvailabilityRequest from ._models_py3 import ReplicationObject from ._models_py3 import ReplicationStatus - from ._models_py3 import ResourceNameAvailability from ._models_py3 import ResourceNameAvailabilityRequest from ._models_py3 import ServiceSpecification from ._models_py3 import Snapshot + from ._models_py3 import SnapshotPolicy + from ._models_py3 import SnapshotPolicyDetails + from ._models_py3 import SnapshotPolicyPatch + from ._models_py3 import SnapshotPolicyVolumeList + from ._models_py3 import Vault from ._models_py3 import Volume + from ._models_py3 import VolumeBackupProperties + from ._models_py3 import VolumeBackups from ._models_py3 import VolumePatch + from ._models_py3 import VolumePatchPropertiesDataProtection from ._models_py3 import VolumePatchPropertiesExportPolicy from ._models_py3 import VolumePropertiesDataProtection from ._models_py3 import VolumePropertiesExportPolicy from ._models_py3 import VolumeRevert from ._models_py3 import VolumeSnapshotProperties + from ._models_py3 import WeeklySchedule except (SyntaxError, ImportError): from ._models import ActiveDirectory from ._models import AuthorizeRequest + from ._models import Backup + from ._models import BackupPatch + from ._models import BackupPolicy + from ._models import BackupPolicyDetails + from ._models import BackupPolicyPatch + from ._models import BackupsList + from ._models import BreakReplicationRequest from ._models import CapacityPool from ._models import CapacityPoolPatch + from ._models import CheckAvailabilityResponse + from ._models import DailySchedule from ._models import Dimension from ._models import ExportPolicyRule + from ._models import HourlySchedule from ._models import MetricSpecification + from ._models import MonthlySchedule from ._models import MountTarget from ._models import MountTargetProperties from ._models import NetAppAccount from ._models import NetAppAccountPatch from ._models import Operation from ._models import OperationDisplay + from ._models import PoolChangeRequest + from ._models import QuotaAvailabilityRequest from ._models import ReplicationObject from ._models import ReplicationStatus - from ._models import ResourceNameAvailability from ._models import ResourceNameAvailabilityRequest from ._models import ServiceSpecification from ._models import Snapshot + from ._models import SnapshotPolicy + from ._models import SnapshotPolicyDetails + from ._models import SnapshotPolicyPatch + from ._models import SnapshotPolicyVolumeList + from ._models import Vault from ._models import Volume + from ._models import VolumeBackupProperties + from ._models import VolumeBackups from ._models import VolumePatch + from ._models import VolumePatchPropertiesDataProtection from ._models import VolumePatchPropertiesExportPolicy from ._models import VolumePropertiesDataProtection from ._models import VolumePropertiesExportPolicy from ._models import VolumeRevert from ._models import VolumeSnapshotProperties + from ._models import WeeklySchedule +from ._paged_models import BackupPaged +from ._paged_models import BackupPolicyPaged from ._paged_models import CapacityPoolPaged from ._paged_models import NetAppAccountPaged from ._paged_models import OperationPaged from ._paged_models import SnapshotPaged +from ._paged_models import SnapshotPolicyPaged +from ._paged_models import VaultPaged from ._paged_models import VolumePaged from ._azure_net_app_files_management_client_enums import ( InAvailabilityReasonType, CheckNameResourceTypes, + CheckQuotaNameResourceTypes, + ActiveDirectoryStatus, ServiceLevel, + QosType, EndpointType, ReplicationSchedule, + SecurityStyle, RelationshipStatus, MirrorState, ) @@ -81,40 +131,69 @@ __all__ = [ 'ActiveDirectory', 'AuthorizeRequest', + 'Backup', + 'BackupPatch', + 'BackupPolicy', + 'BackupPolicyDetails', + 'BackupPolicyPatch', + 'BackupsList', + 'BreakReplicationRequest', 'CapacityPool', 'CapacityPoolPatch', + 'CheckAvailabilityResponse', + 'DailySchedule', 'Dimension', 'ExportPolicyRule', + 'HourlySchedule', 'MetricSpecification', + 'MonthlySchedule', 'MountTarget', 'MountTargetProperties', 'NetAppAccount', 'NetAppAccountPatch', 'Operation', 'OperationDisplay', + 'PoolChangeRequest', + 'QuotaAvailabilityRequest', 'ReplicationObject', 'ReplicationStatus', - 'ResourceNameAvailability', 'ResourceNameAvailabilityRequest', 'ServiceSpecification', 'Snapshot', + 'SnapshotPolicy', + 'SnapshotPolicyDetails', + 'SnapshotPolicyPatch', + 'SnapshotPolicyVolumeList', + 'Vault', 'Volume', + 'VolumeBackupProperties', + 'VolumeBackups', 'VolumePatch', + 'VolumePatchPropertiesDataProtection', 'VolumePatchPropertiesExportPolicy', 'VolumePropertiesDataProtection', 'VolumePropertiesExportPolicy', 'VolumeRevert', 'VolumeSnapshotProperties', + 'WeeklySchedule', 'OperationPaged', 'NetAppAccountPaged', 'CapacityPoolPaged', 'VolumePaged', 'SnapshotPaged', + 'SnapshotPolicyPaged', + 'BackupPaged', + 'BackupPolicyPaged', + 'VaultPaged', 'InAvailabilityReasonType', 'CheckNameResourceTypes', + 'CheckQuotaNameResourceTypes', + 'ActiveDirectoryStatus', 'ServiceLevel', + 'QosType', 'EndpointType', 'ReplicationSchedule', + 'SecurityStyle', 'RelationshipStatus', 'MirrorState', ] diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_azure_net_app_files_management_client_enums.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_azure_net_app_files_management_client_enums.py index 9fe3cca234e5..76b65e6c4c31 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_azure_net_app_files_management_client_enums.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_azure_net_app_files_management_client_enums.py @@ -26,6 +26,23 @@ class CheckNameResourceTypes(str, Enum): microsoft_net_appnet_app_accountscapacity_poolsvolumessnapshots = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots" +class CheckQuotaNameResourceTypes(str, Enum): + + microsoft_net_appnet_app_accounts = "Microsoft.NetApp/netAppAccounts" + microsoft_net_appnet_app_accountscapacity_pools = "Microsoft.NetApp/netAppAccounts/capacityPools" + microsoft_net_appnet_app_accountscapacity_poolsvolumes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes" + microsoft_net_appnet_app_accountscapacity_poolsvolumessnapshots = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots" + + +class ActiveDirectoryStatus(str, Enum): + + created = "Created" #: Active Directory created but not in use + in_use = "InUse" #: Active Directory in use by SMB Volume + deleted = "Deleted" #: Active Directory Deleted + error = "Error" #: Error with the Active Directory + updating = "Updating" #: Active Directory Updating + + class ServiceLevel(str, Enum): standard = "Standard" #: Standard service level @@ -33,6 +50,12 @@ class ServiceLevel(str, Enum): ultra = "Ultra" #: Ultra service level +class QosType(str, Enum): + + auto = "Auto" #: qos type Auto + manual = "Manual" #: qos type Manual + + class EndpointType(str, Enum): src = "src" @@ -48,6 +71,12 @@ class ReplicationSchedule(str, Enum): monthly = "monthly" +class SecurityStyle(str, Enum): + + ntfs = "ntfs" + unix = "unix" + + class RelationshipStatus(str, Enum): idle = "Idle" diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models.py index 493cf97cf428..1724a3684bd8 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models.py @@ -15,20 +15,27 @@ class ActiveDirectory(Model): """Active Directory. + Variables are only populated by the server, and will be ignored when + sending a request. + :param active_directory_id: Id of the Active Directory :type active_directory_id: str :param username: Username of Active Directory domain administrator :type username: str :param password: Plain text password of Active Directory domain - administrator + administrator, value is masked in the response :type password: str :param domain: Name of the Active Directory domain :type domain: str :param dns: Comma separated list of DNS server IP addresses (IPv4 only) for the Active Directory domain :type dns: str - :param status: Status of the Active Directory - :type status: str + :ivar status: Status of the Active Directory. Possible values include: + 'Created', 'InUse', 'Deleted', 'Error', 'Updating' + :vartype status: str or ~azure.mgmt.netapp.models.ActiveDirectoryStatus + :ivar status_details: Any details in regards to the Status of the Active + Directory + :vartype status_details: str :param smb_server_name: NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes :type smb_server_name: str @@ -42,8 +49,28 @@ class ActiveDirectory(Model): active directory group. A list of unique usernames without domain specifier :type backup_operators: list[str] + :param kdc_ip: kdc server IP addresses for the active directory machine. + This optional parameter is used only while creating kerberos volume. + :type kdc_ip: str + :param ad_name: Name of the active directory machine. This optional + parameter is used only while creating kerberos volume + :type ad_name: str + :param server_root_ca_certificate: When LDAP over SSL/TLS is enabled, the + LDAP client is required to have base64 encoded Active Directory + Certificate Service's self-signed root CA certificate, this optional + parameter is used only for dual protocol with LDAP user-mapping volumes. + :type server_root_ca_certificate: str """ + _validation = { + 'dns': {'pattern': r'^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)((, ?)(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$'}, + 'status': {'readonly': True}, + 'status_details': {'readonly': True}, + 'kdc_ip': {'pattern': r'^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)((, ?)(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$'}, + 'ad_name': {'max_length': 64, 'min_length': 1}, + 'server_root_ca_certificate': {'max_length': 10240, 'min_length': 1}, + } + _attribute_map = { 'active_directory_id': {'key': 'activeDirectoryId', 'type': 'str'}, 'username': {'key': 'username', 'type': 'str'}, @@ -51,10 +78,14 @@ class ActiveDirectory(Model): 'domain': {'key': 'domain', 'type': 'str'}, 'dns': {'key': 'dns', 'type': 'str'}, 'status': {'key': 'status', 'type': 'str'}, + 'status_details': {'key': 'statusDetails', 'type': 'str'}, 'smb_server_name': {'key': 'smbServerName', 'type': 'str'}, 'organizational_unit': {'key': 'organizationalUnit', 'type': 'str'}, 'site': {'key': 'site', 'type': 'str'}, 'backup_operators': {'key': 'backupOperators', 'type': '[str]'}, + 'kdc_ip': {'key': 'kdcIP', 'type': 'str'}, + 'ad_name': {'key': 'adName', 'type': 'str'}, + 'server_root_ca_certificate': {'key': 'serverRootCACertificate', 'type': 'str'}, } def __init__(self, **kwargs): @@ -64,11 +95,15 @@ def __init__(self, **kwargs): self.password = kwargs.get('password', None) self.domain = kwargs.get('domain', None) self.dns = kwargs.get('dns', None) - self.status = kwargs.get('status', None) + self.status = None + self.status_details = None self.smb_server_name = kwargs.get('smb_server_name', None) self.organizational_unit = kwargs.get('organizational_unit', None) self.site = kwargs.get('site', None) self.backup_operators = kwargs.get('backup_operators', None) + self.kdc_ip = kwargs.get('kdc_ip', None) + self.ad_name = kwargs.get('ad_name', None) + self.server_root_ca_certificate = kwargs.get('server_root_ca_certificate', None) class AuthorizeRequest(Model): @@ -87,6 +122,370 @@ def __init__(self, **kwargs): self.remote_volume_resource_id = kwargs.get('remote_volume_resource_id', None) +class Backup(Model): + """Backup of a Volume. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :ivar creation_date: name. The creation date of the backup + :vartype creation_date: datetime + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :ivar size: Size of backup + :vartype size: long + :param label: Label for backup + :type label: str + :ivar backup_type: Type of backup adhoc or scheduled + :vartype backup_type: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'creation_date': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + 'size': {'readonly': True}, + 'backup_type': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'creation_date': {'key': 'properties.creationDate', 'type': 'iso-8601'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'size': {'key': 'properties.size', 'type': 'long'}, + 'label': {'key': 'properties.label', 'type': 'str'}, + 'backup_type': {'key': 'properties.backupType', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(Backup, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.creation_date = None + self.provisioning_state = None + self.size = None + self.label = kwargs.get('label', None) + self.backup_type = None + + +class BackupPatch(Model): + """Backup patch. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param tags: Resource tags + :type tags: dict[str, str] + :ivar creation_date: name. The creation date of the backup + :vartype creation_date: datetime + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :ivar size: Size of backup + :vartype size: long + :param label: Label for backup + :type label: str + :ivar backup_type: Type of backup adhoc or scheduled + :vartype backup_type: str + """ + + _validation = { + 'creation_date': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + 'size': {'readonly': True}, + 'backup_type': {'readonly': True}, + } + + _attribute_map = { + 'tags': {'key': 'tags', 'type': '{str}'}, + 'creation_date': {'key': 'properties.creationDate', 'type': 'iso-8601'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'size': {'key': 'properties.size', 'type': 'long'}, + 'label': {'key': 'properties.label', 'type': 'str'}, + 'backup_type': {'key': 'properties.backupType', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(BackupPatch, self).__init__(**kwargs) + self.tags = kwargs.get('tags', None) + self.creation_date = None + self.provisioning_state = None + self.size = None + self.label = kwargs.get('label', None) + self.backup_type = None + + +class BackupPolicy(Model): + """Backup policy information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Name of backup policy + :vartype name1: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, **kwargs): + super(BackupPolicy, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.tags = kwargs.get('tags', None) + self.name1 = None + self.provisioning_state = None + self.daily_backups_to_keep = kwargs.get('daily_backups_to_keep', None) + self.weekly_backups_to_keep = kwargs.get('weekly_backups_to_keep', None) + self.monthly_backups_to_keep = kwargs.get('monthly_backups_to_keep', None) + self.yearly_backups_to_keep = kwargs.get('yearly_backups_to_keep', None) + self.volumes_assigned = kwargs.get('volumes_assigned', None) + self.enabled = kwargs.get('enabled', None) + self.volume_backups = kwargs.get('volume_backups', None) + + +class BackupPolicyDetails(Model): + """Backup policy properties. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Name of backup policy + :vartype name1: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, **kwargs): + super(BackupPolicyDetails, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.tags = kwargs.get('tags', None) + self.name1 = None + self.provisioning_state = None + self.daily_backups_to_keep = kwargs.get('daily_backups_to_keep', None) + self.weekly_backups_to_keep = kwargs.get('weekly_backups_to_keep', None) + self.monthly_backups_to_keep = kwargs.get('monthly_backups_to_keep', None) + self.yearly_backups_to_keep = kwargs.get('yearly_backups_to_keep', None) + self.volumes_assigned = kwargs.get('volumes_assigned', None) + self.enabled = kwargs.get('enabled', None) + self.volume_backups = kwargs.get('volume_backups', None) + + +class BackupPolicyPatch(Model): + """Backup policy Details for create and update. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar name: Name of backup policy + :vartype name: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'name': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'name': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, **kwargs): + super(BackupPolicyPatch, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.name = None + self.provisioning_state = None + self.daily_backups_to_keep = kwargs.get('daily_backups_to_keep', None) + self.weekly_backups_to_keep = kwargs.get('weekly_backups_to_keep', None) + self.monthly_backups_to_keep = kwargs.get('monthly_backups_to_keep', None) + self.yearly_backups_to_keep = kwargs.get('yearly_backups_to_keep', None) + self.volumes_assigned = kwargs.get('volumes_assigned', None) + self.enabled = kwargs.get('enabled', None) + self.volume_backups = kwargs.get('volume_backups', None) + + +class BackupsList(Model): + """List of Backups. + + :param value: A list of Backups + :type value: list[~azure.mgmt.netapp.models.Backup] + """ + + _attribute_map = { + 'value': {'key': 'value', 'type': '[Backup]'}, + } + + def __init__(self, **kwargs): + super(BackupsList, self).__init__(**kwargs) + self.value = kwargs.get('value', None) + + +class BreakReplicationRequest(Model): + """Break replication request. + + :param force_break_replication: If replication is in status transferring + and you want to force break the replication, set to true + :type force_break_replication: bool + """ + + _attribute_map = { + 'force_break_replication': {'key': 'forceBreakReplication', 'type': 'bool'}, + } + + def __init__(self, **kwargs): + super(BreakReplicationRequest, self).__init__(**kwargs) + self.force_break_replication = kwargs.get('force_break_replication', None) + + class CapacityPool(Model): """Capacity pool resource. @@ -117,6 +516,13 @@ class CapacityPool(Model): :type service_level: str or ~azure.mgmt.netapp.models.ServiceLevel :ivar provisioning_state: Azure lifecycle management :vartype provisioning_state: str + :ivar total_throughput_mibps: Total throughput of pool in Mibps + :vartype total_throughput_mibps: float + :ivar utilized_throughput_mibps: Utilized throughput of pool in Mibps + :vartype utilized_throughput_mibps: float + :param qos_type: qosType. The qos type of the pool. Possible values + include: 'Auto', 'Manual'. Default value: "Auto" . + :type qos_type: str or ~azure.mgmt.netapp.models.QosType """ _validation = { @@ -128,6 +534,8 @@ class CapacityPool(Model): 'size': {'required': True, 'maximum': 549755813888000, 'minimum': 4398046511104}, 'service_level': {'required': True}, 'provisioning_state': {'readonly': True}, + 'total_throughput_mibps': {'readonly': True, 'multiple': 0.001}, + 'utilized_throughput_mibps': {'readonly': True, 'multiple': 0.001}, } _attribute_map = { @@ -140,6 +548,9 @@ class CapacityPool(Model): 'size': {'key': 'properties.size', 'type': 'long'}, 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'total_throughput_mibps': {'key': 'properties.totalThroughputMibps', 'type': 'float'}, + 'utilized_throughput_mibps': {'key': 'properties.utilizedThroughputMibps', 'type': 'float'}, + 'qos_type': {'key': 'properties.qosType', 'type': 'str'}, } def __init__(self, **kwargs): @@ -153,6 +564,9 @@ def __init__(self, **kwargs): self.size = kwargs.get('size', None) self.service_level = kwargs.get('service_level', "Premium") self.provisioning_state = None + self.total_throughput_mibps = None + self.utilized_throughput_mibps = None + self.qos_type = kwargs.get('qos_type', "Auto") class CapacityPoolPatch(Model): @@ -175,10 +589,9 @@ class CapacityPoolPatch(Model): are in 4TiB chunks (value must be multiply of 4398046511104). Default value: 4398046511104 . :type size: long - :param service_level: serviceLevel. The service level of the file system. - Possible values include: 'Standard', 'Premium', 'Ultra'. Default value: - "Premium" . - :type service_level: str or ~azure.mgmt.netapp.models.ServiceLevel + :param qos_type: qosType. The qos type of the pool. Possible values + include: 'Auto', 'Manual'. Default value: "Auto" . + :type qos_type: str or ~azure.mgmt.netapp.models.QosType """ _validation = { @@ -195,7 +608,7 @@ class CapacityPoolPatch(Model): 'type': {'key': 'type', 'type': 'str'}, 'tags': {'key': 'tags', 'type': '{str}'}, 'size': {'key': 'properties.size', 'type': 'long'}, - 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, + 'qos_type': {'key': 'properties.qosType', 'type': 'str'}, } def __init__(self, **kwargs): @@ -206,7 +619,40 @@ def __init__(self, **kwargs): self.type = None self.tags = kwargs.get('tags', None) self.size = kwargs.get('size', 4398046511104) - self.service_level = kwargs.get('service_level', "Premium") + self.qos_type = kwargs.get('qos_type', "Auto") + + +class CheckAvailabilityResponse(Model): + """Information regarding availability of a resource. + + :param is_available: true indicates name is valid and + available. false indicates the name is invalid, unavailable, + or both. + :type is_available: bool + :param reason: Invalid indicates the name provided does not + match Azure App Service naming requirements. AlreadyExists + indicates that the name is already in use and is therefore unavailable. + Possible values include: 'Invalid', 'AlreadyExists' + :type reason: str or ~azure.mgmt.netapp.models.InAvailabilityReasonType + :param message: If reason == invalid, provide the user with the reason why + the given name is invalid, and provide the resource naming requirements so + that the user can select a valid name. If reason == AlreadyExists, explain + that resource name is already in use, and direct them to select a + different name. + :type message: str + """ + + _attribute_map = { + 'is_available': {'key': 'isAvailable', 'type': 'bool'}, + 'reason': {'key': 'reason', 'type': 'str'}, + 'message': {'key': 'message', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(CheckAvailabilityResponse, self).__init__(**kwargs) + self.is_available = kwargs.get('is_available', None) + self.reason = kwargs.get('reason', None) + self.message = kwargs.get('message', None) class CloudError(Model): @@ -217,6 +663,36 @@ class CloudError(Model): } +class DailySchedule(Model): + """Daily Schedule properties. + + :param snapshots_to_keep: Daily snapshot count to keep + :type snapshots_to_keep: int + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, **kwargs): + super(DailySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = kwargs.get('snapshots_to_keep', None) + self.hour = kwargs.get('hour', None) + self.minute = kwargs.get('minute', None) + self.used_bytes = kwargs.get('used_bytes', None) + + class Dimension(Model): """Dimension of blobs, possibly be blob type or access tier. @@ -246,6 +722,24 @@ class ExportPolicyRule(Model): :type unix_read_only: bool :param unix_read_write: Read and write access :type unix_read_write: bool + :param kerberos5_read_only: Kerberos5 Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5_read_only: bool + :param kerberos5_read_write: Kerberos5 Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5_read_write: bool + :param kerberos5i_read_only: Kerberos5i Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5i_read_only: bool + :param kerberos5i_read_write: Kerberos5i Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5i_read_write: bool + :param kerberos5p_read_only: Kerberos5p Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5p_read_only: bool + :param kerberos5p_read_write: Kerberos5p Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5p_read_write: bool :param cifs: Allows CIFS protocol :type cifs: bool :param nfsv3: Allows NFSv3 protocol. Enable only for NFSv3 type volumes @@ -256,16 +750,25 @@ class ExportPolicyRule(Model): :param allowed_clients: Client ingress specification as comma separated string with IPv4 CIDRs, IPv4 host addresses and host names :type allowed_clients: str + :param has_root_access: Has root access to volume. Default value: True . + :type has_root_access: bool """ _attribute_map = { 'rule_index': {'key': 'ruleIndex', 'type': 'int'}, 'unix_read_only': {'key': 'unixReadOnly', 'type': 'bool'}, 'unix_read_write': {'key': 'unixReadWrite', 'type': 'bool'}, + 'kerberos5_read_only': {'key': 'kerberos5ReadOnly', 'type': 'bool'}, + 'kerberos5_read_write': {'key': 'kerberos5ReadWrite', 'type': 'bool'}, + 'kerberos5i_read_only': {'key': 'kerberos5iReadOnly', 'type': 'bool'}, + 'kerberos5i_read_write': {'key': 'kerberos5iReadWrite', 'type': 'bool'}, + 'kerberos5p_read_only': {'key': 'kerberos5pReadOnly', 'type': 'bool'}, + 'kerberos5p_read_write': {'key': 'kerberos5pReadWrite', 'type': 'bool'}, 'cifs': {'key': 'cifs', 'type': 'bool'}, 'nfsv3': {'key': 'nfsv3', 'type': 'bool'}, 'nfsv41': {'key': 'nfsv41', 'type': 'bool'}, 'allowed_clients': {'key': 'allowedClients', 'type': 'str'}, + 'has_root_access': {'key': 'hasRootAccess', 'type': 'bool'}, } def __init__(self, **kwargs): @@ -273,10 +776,42 @@ def __init__(self, **kwargs): self.rule_index = kwargs.get('rule_index', None) self.unix_read_only = kwargs.get('unix_read_only', None) self.unix_read_write = kwargs.get('unix_read_write', None) + self.kerberos5_read_only = kwargs.get('kerberos5_read_only', False) + self.kerberos5_read_write = kwargs.get('kerberos5_read_write', False) + self.kerberos5i_read_only = kwargs.get('kerberos5i_read_only', False) + self.kerberos5i_read_write = kwargs.get('kerberos5i_read_write', False) + self.kerberos5p_read_only = kwargs.get('kerberos5p_read_only', False) + self.kerberos5p_read_write = kwargs.get('kerberos5p_read_write', False) self.cifs = kwargs.get('cifs', None) self.nfsv3 = kwargs.get('nfsv3', None) self.nfsv41 = kwargs.get('nfsv41', None) self.allowed_clients = kwargs.get('allowed_clients', None) + self.has_root_access = kwargs.get('has_root_access', True) + + +class HourlySchedule(Model): + """Hourly Schedule properties. + + :param snapshots_to_keep: Hourly snapshot count to keep + :type snapshots_to_keep: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, **kwargs): + super(HourlySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = kwargs.get('snapshots_to_keep', None) + self.minute = kwargs.get('minute', None) + self.used_bytes = kwargs.get('used_bytes', None) class MetricSpecification(Model): @@ -330,6 +865,41 @@ def __init__(self, **kwargs): self.resource_id_dimension_name_override = kwargs.get('resource_id_dimension_name_override', None) +class MonthlySchedule(Model): + """Monthly Schedule properties. + + :param snapshots_to_keep: Monthly snapshot count to keep + :type snapshots_to_keep: int + :param days_of_month: Indicates which days of the month snapshot should be + taken. A comma delimited string. + :type days_of_month: str + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'days_of_month': {'key': 'daysOfMonth', 'type': 'str'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, **kwargs): + super(MonthlySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = kwargs.get('snapshots_to_keep', None) + self.days_of_month = kwargs.get('days_of_month', None) + self.hour = kwargs.get('hour', None) + self.minute = kwargs.get('minute', None) + self.used_bytes = kwargs.get('used_bytes', None) + + class MountTarget(Model): """Mount Target. @@ -356,20 +926,6 @@ class MountTarget(Model): :type file_system_id: str :ivar ip_address: ipAddress. The mount target's IPv4 address :vartype ip_address: str - :param subnet: subnet. The subnet - :type subnet: str - :param start_ip: startIp. The start of IPv4 address range to use when - creating a new mount target - :type start_ip: str - :param end_ip: endIp. The end of IPv4 address range to use when creating a - new mount target - :type end_ip: str - :param gateway: gateway. The gateway of the IPv4 address range to use when - creating a new mount target - :type gateway: str - :param netmask: netmask. The netmask of the IPv4 address range to use when - creating a new mount target - :type netmask: str :param smb_server_fqdn: smbServerFQDN. The SMB server's Fully Qualified Domain Name, FQDN :type smb_server_fqdn: str @@ -394,11 +950,6 @@ class MountTarget(Model): 'mount_target_id': {'key': 'properties.mountTargetId', 'type': 'str'}, 'file_system_id': {'key': 'properties.fileSystemId', 'type': 'str'}, 'ip_address': {'key': 'properties.ipAddress', 'type': 'str'}, - 'subnet': {'key': 'properties.subnet', 'type': 'str'}, - 'start_ip': {'key': 'properties.startIp', 'type': 'str'}, - 'end_ip': {'key': 'properties.endIp', 'type': 'str'}, - 'gateway': {'key': 'properties.gateway', 'type': 'str'}, - 'netmask': {'key': 'properties.netmask', 'type': 'str'}, 'smb_server_fqdn': {'key': 'properties.smbServerFqdn', 'type': 'str'}, } @@ -412,11 +963,6 @@ def __init__(self, **kwargs): self.mount_target_id = None self.file_system_id = kwargs.get('file_system_id', None) self.ip_address = None - self.subnet = kwargs.get('subnet', None) - self.start_ip = kwargs.get('start_ip', None) - self.end_ip = kwargs.get('end_ip', None) - self.gateway = kwargs.get('gateway', None) - self.netmask = kwargs.get('netmask', None) self.smb_server_fqdn = kwargs.get('smb_server_fqdn', None) @@ -436,20 +982,6 @@ class MountTargetProperties(Model): :type file_system_id: str :ivar ip_address: ipAddress. The mount target's IPv4 address :vartype ip_address: str - :param subnet: subnet. The subnet - :type subnet: str - :param start_ip: startIp. The start of IPv4 address range to use when - creating a new mount target - :type start_ip: str - :param end_ip: endIp. The end of IPv4 address range to use when creating a - new mount target - :type end_ip: str - :param gateway: gateway. The gateway of the IPv4 address range to use when - creating a new mount target - :type gateway: str - :param netmask: netmask. The netmask of the IPv4 address range to use when - creating a new mount target - :type netmask: str :param smb_server_fqdn: smbServerFQDN. The SMB server's Fully Qualified Domain Name, FQDN :type smb_server_fqdn: str @@ -465,11 +997,6 @@ class MountTargetProperties(Model): 'mount_target_id': {'key': 'mountTargetId', 'type': 'str'}, 'file_system_id': {'key': 'fileSystemId', 'type': 'str'}, 'ip_address': {'key': 'ipAddress', 'type': 'str'}, - 'subnet': {'key': 'subnet', 'type': 'str'}, - 'start_ip': {'key': 'startIp', 'type': 'str'}, - 'end_ip': {'key': 'endIp', 'type': 'str'}, - 'gateway': {'key': 'gateway', 'type': 'str'}, - 'netmask': {'key': 'netmask', 'type': 'str'}, 'smb_server_fqdn': {'key': 'smbServerFqdn', 'type': 'str'}, } @@ -478,11 +1005,6 @@ def __init__(self, **kwargs): self.mount_target_id = None self.file_system_id = kwargs.get('file_system_id', None) self.ip_address = None - self.subnet = kwargs.get('subnet', None) - self.start_ip = kwargs.get('start_ip', None) - self.end_ip = kwargs.get('end_ip', None) - self.gateway = kwargs.get('gateway', None) - self.netmask = kwargs.get('netmask', None) self.smb_server_fqdn = kwargs.get('smb_server_fqdn', None) @@ -640,11 +1162,70 @@ class OperationDisplay(Model): } def __init__(self, **kwargs): - super(OperationDisplay, self).__init__(**kwargs) - self.provider = kwargs.get('provider', None) - self.resource = kwargs.get('resource', None) - self.operation = kwargs.get('operation', None) - self.description = kwargs.get('description', None) + super(OperationDisplay, self).__init__(**kwargs) + self.provider = kwargs.get('provider', None) + self.resource = kwargs.get('resource', None) + self.operation = kwargs.get('operation', None) + self.description = kwargs.get('description', None) + + +class PoolChangeRequest(Model): + """Pool change request. + + All required parameters must be populated in order to send to Azure. + + :param new_pool_resource_id: Required. Resource id of the pool to move + volume to + :type new_pool_resource_id: str + """ + + _validation = { + 'new_pool_resource_id': {'required': True}, + } + + _attribute_map = { + 'new_pool_resource_id': {'key': 'newPoolResourceId', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(PoolChangeRequest, self).__init__(**kwargs) + self.new_pool_resource_id = kwargs.get('new_pool_resource_id', None) + + +class QuotaAvailabilityRequest(Model): + """Quota availability request content. + + All required parameters must be populated in order to send to Azure. + + :param name: Required. Name of the resource to verify. + :type name: str + :param type: Required. Resource type used for verification. Possible + values include: 'Microsoft.NetApp/netAppAccounts', + 'Microsoft.NetApp/netAppAccounts/capacityPools', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots' + :type type: str or ~azure.mgmt.netapp.models.CheckQuotaNameResourceTypes + :param resource_group: Required. Resource group name. + :type resource_group: str + """ + + _validation = { + 'name': {'required': True}, + 'type': {'required': True}, + 'resource_group': {'required': True}, + } + + _attribute_map = { + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'resource_group': {'key': 'resourceGroup', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(QuotaAvailabilityRequest, self).__init__(**kwargs) + self.name = kwargs.get('name', None) + self.type = kwargs.get('type', None) + self.resource_group = kwargs.get('resource_group', None) class ReplicationObject(Model): @@ -728,39 +1309,6 @@ def __init__(self, **kwargs): self.error_message = kwargs.get('error_message', None) -class ResourceNameAvailability(Model): - """Information regarding availability of a resource name. - - :param is_available: true indicates name is valid and - available. false indicates the name is invalid, unavailable, - or both. - :type is_available: bool - :param reason: Invalid indicates the name provided does not - match Azure App Service naming requirements. AlreadyExists - indicates that the name is already in use and is therefore unavailable. - Possible values include: 'Invalid', 'AlreadyExists' - :type reason: str or ~azure.mgmt.netapp.models.InAvailabilityReasonType - :param message: If reason == invalid, provide the user with the reason why - the given name is invalid, and provide the resource naming requirements so - that the user can select a valid name. If reason == AlreadyExists, explain - that resource name is already in use, and direct them to select a - different name. - :type message: str - """ - - _attribute_map = { - 'is_available': {'key': 'isAvailable', 'type': 'bool'}, - 'reason': {'key': 'reason', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - } - - def __init__(self, **kwargs): - super(ResourceNameAvailability, self).__init__(**kwargs) - self.is_available = kwargs.get('is_available', None) - self.reason = kwargs.get('reason', None) - self.message = kwargs.get('message', None) - - class ResourceNameAvailabilityRequest(Model): """Resource name availability request content. @@ -869,6 +1417,282 @@ def __init__(self, **kwargs): self.provisioning_state = None +class SnapshotPolicy(Model): + """Snapshot policy information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(SnapshotPolicy, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.tags = kwargs.get('tags', None) + self.name1 = None + self.hourly_schedule = kwargs.get('hourly_schedule', None) + self.daily_schedule = kwargs.get('daily_schedule', None) + self.weekly_schedule = kwargs.get('weekly_schedule', None) + self.monthly_schedule = kwargs.get('monthly_schedule', None) + self.enabled = kwargs.get('enabled', None) + self.provisioning_state = None + + +class SnapshotPolicyDetails(Model): + """Snapshot policy properties. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(SnapshotPolicyDetails, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.tags = kwargs.get('tags', None) + self.name1 = None + self.hourly_schedule = kwargs.get('hourly_schedule', None) + self.daily_schedule = kwargs.get('daily_schedule', None) + self.weekly_schedule = kwargs.get('weekly_schedule', None) + self.monthly_schedule = kwargs.get('monthly_schedule', None) + self.enabled = kwargs.get('enabled', None) + self.provisioning_state = None + + +class SnapshotPolicyPatch(Model): + """Snapshot policy Details for create and update. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(SnapshotPolicyPatch, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.tags = kwargs.get('tags', None) + self.name1 = None + self.hourly_schedule = kwargs.get('hourly_schedule', None) + self.daily_schedule = kwargs.get('daily_schedule', None) + self.weekly_schedule = kwargs.get('weekly_schedule', None) + self.monthly_schedule = kwargs.get('monthly_schedule', None) + self.enabled = kwargs.get('enabled', None) + self.provisioning_state = None + + +class SnapshotPolicyVolumeList(Model): + """Volumes associated with snapshot policy. + + :param value: List of volumes + :type value: list[object] + """ + + _attribute_map = { + 'value': {'key': 'value', 'type': '[object]'}, + } + + def __init__(self, **kwargs): + super(SnapshotPolicyVolumeList, self).__init__(**kwargs) + self.value = kwargs.get('value', None) + + +class Vault(Model): + """Vault information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param vault_name: Vault Name + :type vault_name: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'vault_name': {'key': 'properties.vaultName', 'type': 'str'}, + } + + def __init__(self, **kwargs): + super(Vault, self).__init__(**kwargs) + self.location = kwargs.get('location', None) + self.id = None + self.name = None + self.type = None + self.vault_name = kwargs.get('vault_name', None) + + class Volume(Model): """Volume resource. @@ -911,6 +1735,9 @@ class Volume(Model): :param snapshot_id: Snapshot ID. UUID v4 or resource identifier used to identify the Snapshot. :type snapshot_id: str + :param backup_id: Backup ID. UUID v4 or resource identifier used to + identify the Backup. + :type backup_id: str :ivar baremetal_tenant_id: Baremetal Tenant ID. Unique Baremetal Tenant Identifier. :vartype baremetal_tenant_id: str @@ -931,6 +1758,15 @@ class Volume(Model): contain a read-only .snapshot directory which provides access to each of the volume's snapshots (default to true). :type snapshot_directory_visible: bool + :param kerberos_enabled: Describe if a volume is KerberosEnabled. To be + use with swagger version 2020-05-01 or later. Default value: False . + :type kerberos_enabled: bool + :param security_style: The security style of volume. Possible values + include: 'ntfs', 'unix' + :type security_style: str or ~azure.mgmt.netapp.models.SecurityStyle + :param throughput_mibps: Maximum throughput in Mibps that can be achieved + by this volume. + :type throughput_mibps: float """ _validation = { @@ -943,8 +1779,10 @@ class Volume(Model): 'usage_threshold': {'required': True, 'maximum': 109951162777600, 'minimum': 107374182400}, 'provisioning_state': {'readonly': True}, 'snapshot_id': {'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}|(\\?([^\/]*[\/])*)([^\/]+)$'}, + 'backup_id': {'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}|(\\?([^\/]*[\/])*)([^\/]+)$'}, 'baremetal_tenant_id': {'readonly': True, 'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$'}, 'subnet_id': {'required': True}, + 'throughput_mibps': {'maximum': 4500, 'minimum': 1, 'multiple': 0.001}, } _attribute_map = { @@ -961,6 +1799,7 @@ class Volume(Model): 'protocol_types': {'key': 'properties.protocolTypes', 'type': '[str]'}, 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, 'snapshot_id': {'key': 'properties.snapshotId', 'type': 'str'}, + 'backup_id': {'key': 'properties.backupId', 'type': 'str'}, 'baremetal_tenant_id': {'key': 'properties.baremetalTenantId', 'type': 'str'}, 'subnet_id': {'key': 'properties.subnetId', 'type': 'str'}, 'mount_targets': {'key': 'properties.mountTargets', 'type': '[MountTargetProperties]'}, @@ -968,6 +1807,9 @@ class Volume(Model): 'data_protection': {'key': 'properties.dataProtection', 'type': 'VolumePropertiesDataProtection'}, 'is_restoring': {'key': 'properties.isRestoring', 'type': 'bool'}, 'snapshot_directory_visible': {'key': 'properties.snapshotDirectoryVisible', 'type': 'bool'}, + 'kerberos_enabled': {'key': 'properties.kerberosEnabled', 'type': 'bool'}, + 'security_style': {'key': 'properties.securityStyle', 'type': 'str'}, + 'throughput_mibps': {'key': 'properties.throughputMibps', 'type': 'float'}, } def __init__(self, **kwargs): @@ -985,6 +1827,7 @@ def __init__(self, **kwargs): self.protocol_types = kwargs.get('protocol_types', None) self.provisioning_state = None self.snapshot_id = kwargs.get('snapshot_id', None) + self.backup_id = kwargs.get('backup_id', None) self.baremetal_tenant_id = None self.subnet_id = kwargs.get('subnet_id', None) self.mount_targets = kwargs.get('mount_targets', None) @@ -992,6 +1835,61 @@ def __init__(self, **kwargs): self.data_protection = kwargs.get('data_protection', None) self.is_restoring = kwargs.get('is_restoring', None) self.snapshot_directory_visible = kwargs.get('snapshot_directory_visible', None) + self.kerberos_enabled = kwargs.get('kerberos_enabled', False) + self.security_style = kwargs.get('security_style', None) + self.throughput_mibps = kwargs.get('throughput_mibps', None) + + +class VolumeBackupProperties(Model): + """Volume Backup Properties. + + :param backup_policy_id: Backup Policy Resource ID + :type backup_policy_id: str + :param policy_enforced: Policy Enforced + :type policy_enforced: bool + :param vault_id: Vault Resource ID + :type vault_id: str + :param backup_enabled: Backup Enabled + :type backup_enabled: bool + """ + + _attribute_map = { + 'backup_policy_id': {'key': 'backupPolicyId', 'type': 'str'}, + 'policy_enforced': {'key': 'policyEnforced', 'type': 'bool'}, + 'vault_id': {'key': 'vaultId', 'type': 'str'}, + 'backup_enabled': {'key': 'backupEnabled', 'type': 'bool'}, + } + + def __init__(self, **kwargs): + super(VolumeBackupProperties, self).__init__(**kwargs) + self.backup_policy_id = kwargs.get('backup_policy_id', None) + self.policy_enforced = kwargs.get('policy_enforced', None) + self.vault_id = kwargs.get('vault_id', None) + self.backup_enabled = kwargs.get('backup_enabled', None) + + +class VolumeBackups(Model): + """Volume details using the backup policy. + + :param volume_name: Volume name + :type volume_name: str + :param backups_count: Total count of backups for volume + :type backups_count: int + :param policy_enabled: Policy enabled + :type policy_enabled: bool + """ + + _attribute_map = { + 'volume_name': {'key': 'volumeName', 'type': 'str'}, + 'backups_count': {'key': 'backupsCount', 'type': 'int'}, + 'policy_enabled': {'key': 'policyEnabled', 'type': 'bool'}, + } + + def __init__(self, **kwargs): + super(VolumeBackups, self).__init__(**kwargs) + self.volume_name = kwargs.get('volume_name', None) + self.backups_count = kwargs.get('backups_count', None) + self.policy_enabled = kwargs.get('policy_enabled', None) class VolumePatch(Model): @@ -1022,6 +1920,13 @@ class VolumePatch(Model): :param export_policy: exportPolicy. Set of export policy rules :type export_policy: ~azure.mgmt.netapp.models.VolumePatchPropertiesExportPolicy + :param throughput_mibps: Maximum throughput in Mibps that can be achieved + by this volume. + :type throughput_mibps: float + :param data_protection: DataProtection. DataProtection type volumes + include an object containing details of the replication + :type data_protection: + ~azure.mgmt.netapp.models.VolumePatchPropertiesDataProtection """ _validation = { @@ -1029,6 +1934,7 @@ class VolumePatch(Model): 'name': {'readonly': True}, 'type': {'readonly': True}, 'usage_threshold': {'maximum': 109951162777600, 'minimum': 107374182400}, + 'throughput_mibps': {'maximum': 4500, 'minimum': 1, 'multiple': 0.001}, } _attribute_map = { @@ -1040,6 +1946,8 @@ class VolumePatch(Model): 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, 'usage_threshold': {'key': 'properties.usageThreshold', 'type': 'long'}, 'export_policy': {'key': 'properties.exportPolicy', 'type': 'VolumePatchPropertiesExportPolicy'}, + 'throughput_mibps': {'key': 'properties.throughputMibps', 'type': 'float'}, + 'data_protection': {'key': 'properties.dataProtection', 'type': 'VolumePatchPropertiesDataProtection'}, } def __init__(self, **kwargs): @@ -1052,6 +1960,27 @@ def __init__(self, **kwargs): self.service_level = kwargs.get('service_level', "Premium") self.usage_threshold = kwargs.get('usage_threshold', 107374182400) self.export_policy = kwargs.get('export_policy', None) + self.throughput_mibps = kwargs.get('throughput_mibps', None) + self.data_protection = kwargs.get('data_protection', None) + + +class VolumePatchPropertiesDataProtection(Model): + """DataProtection. + + DataProtection type volumes include an object containing details of the + replication. + + :param backup: Backup. Backup Properties + :type backup: ~azure.mgmt.netapp.models.VolumeBackupProperties + """ + + _attribute_map = { + 'backup': {'key': 'backup', 'type': 'VolumeBackupProperties'}, + } + + def __init__(self, **kwargs): + super(VolumePatchPropertiesDataProtection, self).__init__(**kwargs) + self.backup = kwargs.get('backup', None) class VolumePatchPropertiesExportPolicy(Model): @@ -1078,6 +2007,8 @@ class VolumePropertiesDataProtection(Model): DataProtection type volumes include an object containing details of the replication. + :param backup: Backup. Backup Properties + :type backup: ~azure.mgmt.netapp.models.VolumeBackupProperties :param replication: Replication. Replication properties :type replication: ~azure.mgmt.netapp.models.ReplicationObject :param snapshot: Snapshot. Snapshot properties. @@ -1085,12 +2016,14 @@ class VolumePropertiesDataProtection(Model): """ _attribute_map = { + 'backup': {'key': 'backup', 'type': 'VolumeBackupProperties'}, 'replication': {'key': 'replication', 'type': 'ReplicationObject'}, 'snapshot': {'key': 'snapshot', 'type': 'VolumeSnapshotProperties'}, } def __init__(self, **kwargs): super(VolumePropertiesDataProtection, self).__init__(**kwargs) + self.backup = kwargs.get('backup', None) self.replication = kwargs.get('replication', None) self.snapshot = kwargs.get('snapshot', None) @@ -1143,3 +2076,39 @@ class VolumeSnapshotProperties(Model): def __init__(self, **kwargs): super(VolumeSnapshotProperties, self).__init__(**kwargs) self.snapshot_policy_id = kwargs.get('snapshot_policy_id', None) + + +class WeeklySchedule(Model): + """Weekly Schedule properties, make a snapshot every week at a specific day or + days. + + :param snapshots_to_keep: Weekly snapshot count to keep + :type snapshots_to_keep: int + :param day: Indicates which weekdays snapshot should be taken, accepts a + comma separated list of week day names in english + :type day: str + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'day': {'key': 'day', 'type': 'str'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, **kwargs): + super(WeeklySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = kwargs.get('snapshots_to_keep', None) + self.day = kwargs.get('day', None) + self.hour = kwargs.get('hour', None) + self.minute = kwargs.get('minute', None) + self.used_bytes = kwargs.get('used_bytes', None) diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models_py3.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models_py3.py index 7aea0af3da51..8d24a2e099ab 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models_py3.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_models_py3.py @@ -15,20 +15,27 @@ class ActiveDirectory(Model): """Active Directory. + Variables are only populated by the server, and will be ignored when + sending a request. + :param active_directory_id: Id of the Active Directory :type active_directory_id: str :param username: Username of Active Directory domain administrator :type username: str :param password: Plain text password of Active Directory domain - administrator + administrator, value is masked in the response :type password: str :param domain: Name of the Active Directory domain :type domain: str :param dns: Comma separated list of DNS server IP addresses (IPv4 only) for the Active Directory domain :type dns: str - :param status: Status of the Active Directory - :type status: str + :ivar status: Status of the Active Directory. Possible values include: + 'Created', 'InUse', 'Deleted', 'Error', 'Updating' + :vartype status: str or ~azure.mgmt.netapp.models.ActiveDirectoryStatus + :ivar status_details: Any details in regards to the Status of the Active + Directory + :vartype status_details: str :param smb_server_name: NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes :type smb_server_name: str @@ -42,8 +49,28 @@ class ActiveDirectory(Model): active directory group. A list of unique usernames without domain specifier :type backup_operators: list[str] + :param kdc_ip: kdc server IP addresses for the active directory machine. + This optional parameter is used only while creating kerberos volume. + :type kdc_ip: str + :param ad_name: Name of the active directory machine. This optional + parameter is used only while creating kerberos volume + :type ad_name: str + :param server_root_ca_certificate: When LDAP over SSL/TLS is enabled, the + LDAP client is required to have base64 encoded Active Directory + Certificate Service's self-signed root CA certificate, this optional + parameter is used only for dual protocol with LDAP user-mapping volumes. + :type server_root_ca_certificate: str """ + _validation = { + 'dns': {'pattern': r'^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)((, ?)(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$'}, + 'status': {'readonly': True}, + 'status_details': {'readonly': True}, + 'kdc_ip': {'pattern': r'^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)((, ?)(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$'}, + 'ad_name': {'max_length': 64, 'min_length': 1}, + 'server_root_ca_certificate': {'max_length': 10240, 'min_length': 1}, + } + _attribute_map = { 'active_directory_id': {'key': 'activeDirectoryId', 'type': 'str'}, 'username': {'key': 'username', 'type': 'str'}, @@ -51,24 +78,32 @@ class ActiveDirectory(Model): 'domain': {'key': 'domain', 'type': 'str'}, 'dns': {'key': 'dns', 'type': 'str'}, 'status': {'key': 'status', 'type': 'str'}, + 'status_details': {'key': 'statusDetails', 'type': 'str'}, 'smb_server_name': {'key': 'smbServerName', 'type': 'str'}, 'organizational_unit': {'key': 'organizationalUnit', 'type': 'str'}, 'site': {'key': 'site', 'type': 'str'}, 'backup_operators': {'key': 'backupOperators', 'type': '[str]'}, + 'kdc_ip': {'key': 'kdcIP', 'type': 'str'}, + 'ad_name': {'key': 'adName', 'type': 'str'}, + 'server_root_ca_certificate': {'key': 'serverRootCACertificate', 'type': 'str'}, } - def __init__(self, *, active_directory_id: str=None, username: str=None, password: str=None, domain: str=None, dns: str=None, status: str=None, smb_server_name: str=None, organizational_unit: str=None, site: str=None, backup_operators=None, **kwargs) -> None: + def __init__(self, *, active_directory_id: str=None, username: str=None, password: str=None, domain: str=None, dns: str=None, smb_server_name: str=None, organizational_unit: str=None, site: str=None, backup_operators=None, kdc_ip: str=None, ad_name: str=None, server_root_ca_certificate: str=None, **kwargs) -> None: super(ActiveDirectory, self).__init__(**kwargs) self.active_directory_id = active_directory_id self.username = username self.password = password self.domain = domain self.dns = dns - self.status = status + self.status = None + self.status_details = None self.smb_server_name = smb_server_name self.organizational_unit = organizational_unit self.site = site self.backup_operators = backup_operators + self.kdc_ip = kdc_ip + self.ad_name = ad_name + self.server_root_ca_certificate = server_root_ca_certificate class AuthorizeRequest(Model): @@ -87,6 +122,370 @@ def __init__(self, *, remote_volume_resource_id: str=None, **kwargs) -> None: self.remote_volume_resource_id = remote_volume_resource_id +class Backup(Model): + """Backup of a Volume. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :ivar creation_date: name. The creation date of the backup + :vartype creation_date: datetime + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :ivar size: Size of backup + :vartype size: long + :param label: Label for backup + :type label: str + :ivar backup_type: Type of backup adhoc or scheduled + :vartype backup_type: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'creation_date': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + 'size': {'readonly': True}, + 'backup_type': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'creation_date': {'key': 'properties.creationDate', 'type': 'iso-8601'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'size': {'key': 'properties.size', 'type': 'long'}, + 'label': {'key': 'properties.label', 'type': 'str'}, + 'backup_type': {'key': 'properties.backupType', 'type': 'str'}, + } + + def __init__(self, *, location: str, label: str=None, **kwargs) -> None: + super(Backup, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.creation_date = None + self.provisioning_state = None + self.size = None + self.label = label + self.backup_type = None + + +class BackupPatch(Model): + """Backup patch. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param tags: Resource tags + :type tags: dict[str, str] + :ivar creation_date: name. The creation date of the backup + :vartype creation_date: datetime + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :ivar size: Size of backup + :vartype size: long + :param label: Label for backup + :type label: str + :ivar backup_type: Type of backup adhoc or scheduled + :vartype backup_type: str + """ + + _validation = { + 'creation_date': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + 'size': {'readonly': True}, + 'backup_type': {'readonly': True}, + } + + _attribute_map = { + 'tags': {'key': 'tags', 'type': '{str}'}, + 'creation_date': {'key': 'properties.creationDate', 'type': 'iso-8601'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'size': {'key': 'properties.size', 'type': 'long'}, + 'label': {'key': 'properties.label', 'type': 'str'}, + 'backup_type': {'key': 'properties.backupType', 'type': 'str'}, + } + + def __init__(self, *, tags=None, label: str=None, **kwargs) -> None: + super(BackupPatch, self).__init__(**kwargs) + self.tags = tags + self.creation_date = None + self.provisioning_state = None + self.size = None + self.label = label + self.backup_type = None + + +class BackupPolicy(Model): + """Backup policy information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Name of backup policy + :vartype name1: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, *, location: str, tags=None, daily_backups_to_keep: int=None, weekly_backups_to_keep: int=None, monthly_backups_to_keep: int=None, yearly_backups_to_keep: int=None, volumes_assigned: int=None, enabled: bool=None, volume_backups=None, **kwargs) -> None: + super(BackupPolicy, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.tags = tags + self.name1 = None + self.provisioning_state = None + self.daily_backups_to_keep = daily_backups_to_keep + self.weekly_backups_to_keep = weekly_backups_to_keep + self.monthly_backups_to_keep = monthly_backups_to_keep + self.yearly_backups_to_keep = yearly_backups_to_keep + self.volumes_assigned = volumes_assigned + self.enabled = enabled + self.volume_backups = volume_backups + + +class BackupPolicyDetails(Model): + """Backup policy properties. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Name of backup policy + :vartype name1: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, *, location: str=None, tags=None, daily_backups_to_keep: int=None, weekly_backups_to_keep: int=None, monthly_backups_to_keep: int=None, yearly_backups_to_keep: int=None, volumes_assigned: int=None, enabled: bool=None, volume_backups=None, **kwargs) -> None: + super(BackupPolicyDetails, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.tags = tags + self.name1 = None + self.provisioning_state = None + self.daily_backups_to_keep = daily_backups_to_keep + self.weekly_backups_to_keep = weekly_backups_to_keep + self.monthly_backups_to_keep = monthly_backups_to_keep + self.yearly_backups_to_keep = yearly_backups_to_keep + self.volumes_assigned = volumes_assigned + self.enabled = enabled + self.volume_backups = volume_backups + + +class BackupPolicyPatch(Model): + """Backup policy Details for create and update. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar name: Name of backup policy + :vartype name: str + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + :param daily_backups_to_keep: Daily backups count to keep + :type daily_backups_to_keep: int + :param weekly_backups_to_keep: Weekly backups count to keep + :type weekly_backups_to_keep: int + :param monthly_backups_to_keep: Monthly backups count to keep + :type monthly_backups_to_keep: int + :param yearly_backups_to_keep: Yearly backups count to keep + :type yearly_backups_to_keep: int + :param volumes_assigned: Volumes using current backup policy + :type volumes_assigned: int + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :param volume_backups: A list of volumes assigned to this policy + :type volume_backups: list[~azure.mgmt.netapp.models.VolumeBackups] + """ + + _validation = { + 'name': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'name': {'key': 'properties.name', 'type': 'str'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'daily_backups_to_keep': {'key': 'properties.dailyBackupsToKeep', 'type': 'int'}, + 'weekly_backups_to_keep': {'key': 'properties.weeklyBackupsToKeep', 'type': 'int'}, + 'monthly_backups_to_keep': {'key': 'properties.monthlyBackupsToKeep', 'type': 'int'}, + 'yearly_backups_to_keep': {'key': 'properties.yearlyBackupsToKeep', 'type': 'int'}, + 'volumes_assigned': {'key': 'properties.volumesAssigned', 'type': 'int'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'volume_backups': {'key': 'properties.volumeBackups', 'type': '[VolumeBackups]'}, + } + + def __init__(self, *, location: str=None, daily_backups_to_keep: int=None, weekly_backups_to_keep: int=None, monthly_backups_to_keep: int=None, yearly_backups_to_keep: int=None, volumes_assigned: int=None, enabled: bool=None, volume_backups=None, **kwargs) -> None: + super(BackupPolicyPatch, self).__init__(**kwargs) + self.location = location + self.name = None + self.provisioning_state = None + self.daily_backups_to_keep = daily_backups_to_keep + self.weekly_backups_to_keep = weekly_backups_to_keep + self.monthly_backups_to_keep = monthly_backups_to_keep + self.yearly_backups_to_keep = yearly_backups_to_keep + self.volumes_assigned = volumes_assigned + self.enabled = enabled + self.volume_backups = volume_backups + + +class BackupsList(Model): + """List of Backups. + + :param value: A list of Backups + :type value: list[~azure.mgmt.netapp.models.Backup] + """ + + _attribute_map = { + 'value': {'key': 'value', 'type': '[Backup]'}, + } + + def __init__(self, *, value=None, **kwargs) -> None: + super(BackupsList, self).__init__(**kwargs) + self.value = value + + +class BreakReplicationRequest(Model): + """Break replication request. + + :param force_break_replication: If replication is in status transferring + and you want to force break the replication, set to true + :type force_break_replication: bool + """ + + _attribute_map = { + 'force_break_replication': {'key': 'forceBreakReplication', 'type': 'bool'}, + } + + def __init__(self, *, force_break_replication: bool=None, **kwargs) -> None: + super(BreakReplicationRequest, self).__init__(**kwargs) + self.force_break_replication = force_break_replication + + class CapacityPool(Model): """Capacity pool resource. @@ -117,6 +516,13 @@ class CapacityPool(Model): :type service_level: str or ~azure.mgmt.netapp.models.ServiceLevel :ivar provisioning_state: Azure lifecycle management :vartype provisioning_state: str + :ivar total_throughput_mibps: Total throughput of pool in Mibps + :vartype total_throughput_mibps: float + :ivar utilized_throughput_mibps: Utilized throughput of pool in Mibps + :vartype utilized_throughput_mibps: float + :param qos_type: qosType. The qos type of the pool. Possible values + include: 'Auto', 'Manual'. Default value: "Auto" . + :type qos_type: str or ~azure.mgmt.netapp.models.QosType """ _validation = { @@ -128,6 +534,8 @@ class CapacityPool(Model): 'size': {'required': True, 'maximum': 549755813888000, 'minimum': 4398046511104}, 'service_level': {'required': True}, 'provisioning_state': {'readonly': True}, + 'total_throughput_mibps': {'readonly': True, 'multiple': 0.001}, + 'utilized_throughput_mibps': {'readonly': True, 'multiple': 0.001}, } _attribute_map = { @@ -140,9 +548,12 @@ class CapacityPool(Model): 'size': {'key': 'properties.size', 'type': 'long'}, 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + 'total_throughput_mibps': {'key': 'properties.totalThroughputMibps', 'type': 'float'}, + 'utilized_throughput_mibps': {'key': 'properties.utilizedThroughputMibps', 'type': 'float'}, + 'qos_type': {'key': 'properties.qosType', 'type': 'str'}, } - def __init__(self, *, location: str, size: int, tags=None, service_level="Premium", **kwargs) -> None: + def __init__(self, *, location: str, size: int, tags=None, service_level="Premium", qos_type="Auto", **kwargs) -> None: super(CapacityPool, self).__init__(**kwargs) self.location = location self.id = None @@ -153,6 +564,9 @@ def __init__(self, *, location: str, size: int, tags=None, service_level="Premiu self.size = size self.service_level = service_level self.provisioning_state = None + self.total_throughput_mibps = None + self.utilized_throughput_mibps = None + self.qos_type = qos_type class CapacityPoolPatch(Model): @@ -175,10 +589,9 @@ class CapacityPoolPatch(Model): are in 4TiB chunks (value must be multiply of 4398046511104). Default value: 4398046511104 . :type size: long - :param service_level: serviceLevel. The service level of the file system. - Possible values include: 'Standard', 'Premium', 'Ultra'. Default value: - "Premium" . - :type service_level: str or ~azure.mgmt.netapp.models.ServiceLevel + :param qos_type: qosType. The qos type of the pool. Possible values + include: 'Auto', 'Manual'. Default value: "Auto" . + :type qos_type: str or ~azure.mgmt.netapp.models.QosType """ _validation = { @@ -195,10 +608,10 @@ class CapacityPoolPatch(Model): 'type': {'key': 'type', 'type': 'str'}, 'tags': {'key': 'tags', 'type': '{str}'}, 'size': {'key': 'properties.size', 'type': 'long'}, - 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, + 'qos_type': {'key': 'properties.qosType', 'type': 'str'}, } - def __init__(self, *, location: str=None, tags=None, size: int=4398046511104, service_level="Premium", **kwargs) -> None: + def __init__(self, *, location: str=None, tags=None, size: int=4398046511104, qos_type="Auto", **kwargs) -> None: super(CapacityPoolPatch, self).__init__(**kwargs) self.location = location self.id = None @@ -206,7 +619,40 @@ def __init__(self, *, location: str=None, tags=None, size: int=4398046511104, se self.type = None self.tags = tags self.size = size - self.service_level = service_level + self.qos_type = qos_type + + +class CheckAvailabilityResponse(Model): + """Information regarding availability of a resource. + + :param is_available: true indicates name is valid and + available. false indicates the name is invalid, unavailable, + or both. + :type is_available: bool + :param reason: Invalid indicates the name provided does not + match Azure App Service naming requirements. AlreadyExists + indicates that the name is already in use and is therefore unavailable. + Possible values include: 'Invalid', 'AlreadyExists' + :type reason: str or ~azure.mgmt.netapp.models.InAvailabilityReasonType + :param message: If reason == invalid, provide the user with the reason why + the given name is invalid, and provide the resource naming requirements so + that the user can select a valid name. If reason == AlreadyExists, explain + that resource name is already in use, and direct them to select a + different name. + :type message: str + """ + + _attribute_map = { + 'is_available': {'key': 'isAvailable', 'type': 'bool'}, + 'reason': {'key': 'reason', 'type': 'str'}, + 'message': {'key': 'message', 'type': 'str'}, + } + + def __init__(self, *, is_available: bool=None, reason=None, message: str=None, **kwargs) -> None: + super(CheckAvailabilityResponse, self).__init__(**kwargs) + self.is_available = is_available + self.reason = reason + self.message = message class CloudError(Model): @@ -217,6 +663,36 @@ class CloudError(Model): } +class DailySchedule(Model): + """Daily Schedule properties. + + :param snapshots_to_keep: Daily snapshot count to keep + :type snapshots_to_keep: int + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, *, snapshots_to_keep: int=None, hour: int=None, minute: int=None, used_bytes: int=None, **kwargs) -> None: + super(DailySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = snapshots_to_keep + self.hour = hour + self.minute = minute + self.used_bytes = used_bytes + + class Dimension(Model): """Dimension of blobs, possibly be blob type or access tier. @@ -246,6 +722,24 @@ class ExportPolicyRule(Model): :type unix_read_only: bool :param unix_read_write: Read and write access :type unix_read_write: bool + :param kerberos5_read_only: Kerberos5 Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5_read_only: bool + :param kerberos5_read_write: Kerberos5 Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5_read_write: bool + :param kerberos5i_read_only: Kerberos5i Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5i_read_only: bool + :param kerberos5i_read_write: Kerberos5i Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5i_read_write: bool + :param kerberos5p_read_only: Kerberos5p Read only access. To be use with + swagger version 2020-05-01 or later. Default value: False . + :type kerberos5p_read_only: bool + :param kerberos5p_read_write: Kerberos5p Read and write access. To be use + with swagger version 2020-05-01 or later. Default value: False . + :type kerberos5p_read_write: bool :param cifs: Allows CIFS protocol :type cifs: bool :param nfsv3: Allows NFSv3 protocol. Enable only for NFSv3 type volumes @@ -256,27 +750,68 @@ class ExportPolicyRule(Model): :param allowed_clients: Client ingress specification as comma separated string with IPv4 CIDRs, IPv4 host addresses and host names :type allowed_clients: str + :param has_root_access: Has root access to volume. Default value: True . + :type has_root_access: bool """ _attribute_map = { 'rule_index': {'key': 'ruleIndex', 'type': 'int'}, 'unix_read_only': {'key': 'unixReadOnly', 'type': 'bool'}, 'unix_read_write': {'key': 'unixReadWrite', 'type': 'bool'}, + 'kerberos5_read_only': {'key': 'kerberos5ReadOnly', 'type': 'bool'}, + 'kerberos5_read_write': {'key': 'kerberos5ReadWrite', 'type': 'bool'}, + 'kerberos5i_read_only': {'key': 'kerberos5iReadOnly', 'type': 'bool'}, + 'kerberos5i_read_write': {'key': 'kerberos5iReadWrite', 'type': 'bool'}, + 'kerberos5p_read_only': {'key': 'kerberos5pReadOnly', 'type': 'bool'}, + 'kerberos5p_read_write': {'key': 'kerberos5pReadWrite', 'type': 'bool'}, 'cifs': {'key': 'cifs', 'type': 'bool'}, 'nfsv3': {'key': 'nfsv3', 'type': 'bool'}, 'nfsv41': {'key': 'nfsv41', 'type': 'bool'}, 'allowed_clients': {'key': 'allowedClients', 'type': 'str'}, + 'has_root_access': {'key': 'hasRootAccess', 'type': 'bool'}, } - def __init__(self, *, rule_index: int=None, unix_read_only: bool=None, unix_read_write: bool=None, cifs: bool=None, nfsv3: bool=None, nfsv41: bool=None, allowed_clients: str=None, **kwargs) -> None: + def __init__(self, *, rule_index: int=None, unix_read_only: bool=None, unix_read_write: bool=None, kerberos5_read_only: bool=False, kerberos5_read_write: bool=False, kerberos5i_read_only: bool=False, kerberos5i_read_write: bool=False, kerberos5p_read_only: bool=False, kerberos5p_read_write: bool=False, cifs: bool=None, nfsv3: bool=None, nfsv41: bool=None, allowed_clients: str=None, has_root_access: bool=True, **kwargs) -> None: super(ExportPolicyRule, self).__init__(**kwargs) self.rule_index = rule_index self.unix_read_only = unix_read_only self.unix_read_write = unix_read_write + self.kerberos5_read_only = kerberos5_read_only + self.kerberos5_read_write = kerberos5_read_write + self.kerberos5i_read_only = kerberos5i_read_only + self.kerberos5i_read_write = kerberos5i_read_write + self.kerberos5p_read_only = kerberos5p_read_only + self.kerberos5p_read_write = kerberos5p_read_write self.cifs = cifs self.nfsv3 = nfsv3 self.nfsv41 = nfsv41 self.allowed_clients = allowed_clients + self.has_root_access = has_root_access + + +class HourlySchedule(Model): + """Hourly Schedule properties. + + :param snapshots_to_keep: Hourly snapshot count to keep + :type snapshots_to_keep: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, *, snapshots_to_keep: int=None, minute: int=None, used_bytes: int=None, **kwargs) -> None: + super(HourlySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = snapshots_to_keep + self.minute = minute + self.used_bytes = used_bytes class MetricSpecification(Model): @@ -330,6 +865,41 @@ def __init__(self, *, name: str=None, display_name: str=None, display_descriptio self.resource_id_dimension_name_override = resource_id_dimension_name_override +class MonthlySchedule(Model): + """Monthly Schedule properties. + + :param snapshots_to_keep: Monthly snapshot count to keep + :type snapshots_to_keep: int + :param days_of_month: Indicates which days of the month snapshot should be + taken. A comma delimited string. + :type days_of_month: str + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'days_of_month': {'key': 'daysOfMonth', 'type': 'str'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, *, snapshots_to_keep: int=None, days_of_month: str=None, hour: int=None, minute: int=None, used_bytes: int=None, **kwargs) -> None: + super(MonthlySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = snapshots_to_keep + self.days_of_month = days_of_month + self.hour = hour + self.minute = minute + self.used_bytes = used_bytes + + class MountTarget(Model): """Mount Target. @@ -356,20 +926,6 @@ class MountTarget(Model): :type file_system_id: str :ivar ip_address: ipAddress. The mount target's IPv4 address :vartype ip_address: str - :param subnet: subnet. The subnet - :type subnet: str - :param start_ip: startIp. The start of IPv4 address range to use when - creating a new mount target - :type start_ip: str - :param end_ip: endIp. The end of IPv4 address range to use when creating a - new mount target - :type end_ip: str - :param gateway: gateway. The gateway of the IPv4 address range to use when - creating a new mount target - :type gateway: str - :param netmask: netmask. The netmask of the IPv4 address range to use when - creating a new mount target - :type netmask: str :param smb_server_fqdn: smbServerFQDN. The SMB server's Fully Qualified Domain Name, FQDN :type smb_server_fqdn: str @@ -394,15 +950,10 @@ class MountTarget(Model): 'mount_target_id': {'key': 'properties.mountTargetId', 'type': 'str'}, 'file_system_id': {'key': 'properties.fileSystemId', 'type': 'str'}, 'ip_address': {'key': 'properties.ipAddress', 'type': 'str'}, - 'subnet': {'key': 'properties.subnet', 'type': 'str'}, - 'start_ip': {'key': 'properties.startIp', 'type': 'str'}, - 'end_ip': {'key': 'properties.endIp', 'type': 'str'}, - 'gateway': {'key': 'properties.gateway', 'type': 'str'}, - 'netmask': {'key': 'properties.netmask', 'type': 'str'}, 'smb_server_fqdn': {'key': 'properties.smbServerFqdn', 'type': 'str'}, } - def __init__(self, *, location: str, file_system_id: str, tags=None, subnet: str=None, start_ip: str=None, end_ip: str=None, gateway: str=None, netmask: str=None, smb_server_fqdn: str=None, **kwargs) -> None: + def __init__(self, *, location: str, file_system_id: str, tags=None, smb_server_fqdn: str=None, **kwargs) -> None: super(MountTarget, self).__init__(**kwargs) self.location = location self.id = None @@ -412,11 +963,6 @@ def __init__(self, *, location: str, file_system_id: str, tags=None, subnet: str self.mount_target_id = None self.file_system_id = file_system_id self.ip_address = None - self.subnet = subnet - self.start_ip = start_ip - self.end_ip = end_ip - self.gateway = gateway - self.netmask = netmask self.smb_server_fqdn = smb_server_fqdn @@ -436,20 +982,6 @@ class MountTargetProperties(Model): :type file_system_id: str :ivar ip_address: ipAddress. The mount target's IPv4 address :vartype ip_address: str - :param subnet: subnet. The subnet - :type subnet: str - :param start_ip: startIp. The start of IPv4 address range to use when - creating a new mount target - :type start_ip: str - :param end_ip: endIp. The end of IPv4 address range to use when creating a - new mount target - :type end_ip: str - :param gateway: gateway. The gateway of the IPv4 address range to use when - creating a new mount target - :type gateway: str - :param netmask: netmask. The netmask of the IPv4 address range to use when - creating a new mount target - :type netmask: str :param smb_server_fqdn: smbServerFQDN. The SMB server's Fully Qualified Domain Name, FQDN :type smb_server_fqdn: str @@ -465,24 +997,14 @@ class MountTargetProperties(Model): 'mount_target_id': {'key': 'mountTargetId', 'type': 'str'}, 'file_system_id': {'key': 'fileSystemId', 'type': 'str'}, 'ip_address': {'key': 'ipAddress', 'type': 'str'}, - 'subnet': {'key': 'subnet', 'type': 'str'}, - 'start_ip': {'key': 'startIp', 'type': 'str'}, - 'end_ip': {'key': 'endIp', 'type': 'str'}, - 'gateway': {'key': 'gateway', 'type': 'str'}, - 'netmask': {'key': 'netmask', 'type': 'str'}, 'smb_server_fqdn': {'key': 'smbServerFqdn', 'type': 'str'}, } - def __init__(self, *, file_system_id: str, subnet: str=None, start_ip: str=None, end_ip: str=None, gateway: str=None, netmask: str=None, smb_server_fqdn: str=None, **kwargs) -> None: + def __init__(self, *, file_system_id: str, smb_server_fqdn: str=None, **kwargs) -> None: super(MountTargetProperties, self).__init__(**kwargs) self.mount_target_id = None self.file_system_id = file_system_id self.ip_address = None - self.subnet = subnet - self.start_ip = start_ip - self.end_ip = end_ip - self.gateway = gateway - self.netmask = netmask self.smb_server_fqdn = smb_server_fqdn @@ -633,18 +1155,77 @@ class OperationDisplay(Model): """ _attribute_map = { - 'provider': {'key': 'provider', 'type': 'str'}, - 'resource': {'key': 'resource', 'type': 'str'}, - 'operation': {'key': 'operation', 'type': 'str'}, - 'description': {'key': 'description', 'type': 'str'}, + 'provider': {'key': 'provider', 'type': 'str'}, + 'resource': {'key': 'resource', 'type': 'str'}, + 'operation': {'key': 'operation', 'type': 'str'}, + 'description': {'key': 'description', 'type': 'str'}, + } + + def __init__(self, *, provider: str=None, resource: str=None, operation: str=None, description: str=None, **kwargs) -> None: + super(OperationDisplay, self).__init__(**kwargs) + self.provider = provider + self.resource = resource + self.operation = operation + self.description = description + + +class PoolChangeRequest(Model): + """Pool change request. + + All required parameters must be populated in order to send to Azure. + + :param new_pool_resource_id: Required. Resource id of the pool to move + volume to + :type new_pool_resource_id: str + """ + + _validation = { + 'new_pool_resource_id': {'required': True}, + } + + _attribute_map = { + 'new_pool_resource_id': {'key': 'newPoolResourceId', 'type': 'str'}, + } + + def __init__(self, *, new_pool_resource_id: str, **kwargs) -> None: + super(PoolChangeRequest, self).__init__(**kwargs) + self.new_pool_resource_id = new_pool_resource_id + + +class QuotaAvailabilityRequest(Model): + """Quota availability request content. + + All required parameters must be populated in order to send to Azure. + + :param name: Required. Name of the resource to verify. + :type name: str + :param type: Required. Resource type used for verification. Possible + values include: 'Microsoft.NetApp/netAppAccounts', + 'Microsoft.NetApp/netAppAccounts/capacityPools', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots' + :type type: str or ~azure.mgmt.netapp.models.CheckQuotaNameResourceTypes + :param resource_group: Required. Resource group name. + :type resource_group: str + """ + + _validation = { + 'name': {'required': True}, + 'type': {'required': True}, + 'resource_group': {'required': True}, + } + + _attribute_map = { + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'resource_group': {'key': 'resourceGroup', 'type': 'str'}, } - def __init__(self, *, provider: str=None, resource: str=None, operation: str=None, description: str=None, **kwargs) -> None: - super(OperationDisplay, self).__init__(**kwargs) - self.provider = provider - self.resource = resource - self.operation = operation - self.description = description + def __init__(self, *, name: str, type, resource_group: str, **kwargs) -> None: + super(QuotaAvailabilityRequest, self).__init__(**kwargs) + self.name = name + self.type = type + self.resource_group = resource_group class ReplicationObject(Model): @@ -728,39 +1309,6 @@ def __init__(self, *, healthy: bool=None, relationship_status=None, mirror_state self.error_message = error_message -class ResourceNameAvailability(Model): - """Information regarding availability of a resource name. - - :param is_available: true indicates name is valid and - available. false indicates the name is invalid, unavailable, - or both. - :type is_available: bool - :param reason: Invalid indicates the name provided does not - match Azure App Service naming requirements. AlreadyExists - indicates that the name is already in use and is therefore unavailable. - Possible values include: 'Invalid', 'AlreadyExists' - :type reason: str or ~azure.mgmt.netapp.models.InAvailabilityReasonType - :param message: If reason == invalid, provide the user with the reason why - the given name is invalid, and provide the resource naming requirements so - that the user can select a valid name. If reason == AlreadyExists, explain - that resource name is already in use, and direct them to select a - different name. - :type message: str - """ - - _attribute_map = { - 'is_available': {'key': 'isAvailable', 'type': 'bool'}, - 'reason': {'key': 'reason', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - } - - def __init__(self, *, is_available: bool=None, reason=None, message: str=None, **kwargs) -> None: - super(ResourceNameAvailability, self).__init__(**kwargs) - self.is_available = is_available - self.reason = reason - self.message = message - - class ResourceNameAvailabilityRequest(Model): """Resource name availability request content. @@ -869,6 +1417,282 @@ def __init__(self, *, location: str, **kwargs) -> None: self.provisioning_state = None +class SnapshotPolicy(Model): + """Snapshot policy information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, *, location: str, tags=None, hourly_schedule=None, daily_schedule=None, weekly_schedule=None, monthly_schedule=None, enabled: bool=None, **kwargs) -> None: + super(SnapshotPolicy, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.tags = tags + self.name1 = None + self.hourly_schedule = hourly_schedule + self.daily_schedule = daily_schedule + self.weekly_schedule = weekly_schedule + self.monthly_schedule = monthly_schedule + self.enabled = enabled + self.provisioning_state = None + + +class SnapshotPolicyDetails(Model): + """Snapshot policy properties. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, *, location: str=None, tags=None, hourly_schedule=None, daily_schedule=None, weekly_schedule=None, monthly_schedule=None, enabled: bool=None, **kwargs) -> None: + super(SnapshotPolicyDetails, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.tags = tags + self.name1 = None + self.hourly_schedule = hourly_schedule + self.daily_schedule = daily_schedule + self.weekly_schedule = weekly_schedule + self.monthly_schedule = monthly_schedule + self.enabled = enabled + self.provisioning_state = None + + +class SnapshotPolicyPatch(Model): + """Snapshot policy Details for create and update. + + Variables are only populated by the server, and will be ignored when + sending a request. + + :param location: Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param tags: Resource tags + :type tags: dict[str, str] + :ivar name1: Snapshot policy name + :vartype name1: str + :param hourly_schedule: hourlySchedule. Schedule for hourly snapshots + :type hourly_schedule: ~azure.mgmt.netapp.models.HourlySchedule + :param daily_schedule: dailySchedule. Schedule for daily snapshots + :type daily_schedule: ~azure.mgmt.netapp.models.DailySchedule + :param weekly_schedule: weeklySchedule. Schedule for weekly snapshots + :type weekly_schedule: ~azure.mgmt.netapp.models.WeeklySchedule + :param monthly_schedule: monthlySchedule. Schedule for monthly snapshots + :type monthly_schedule: ~azure.mgmt.netapp.models.MonthlySchedule + :param enabled: The property to decide policy is enabled or not + :type enabled: bool + :ivar provisioning_state: Azure lifecycle management + :vartype provisioning_state: str + """ + + _validation = { + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + 'name1': {'readonly': True}, + 'provisioning_state': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'tags': {'key': 'tags', 'type': '{str}'}, + 'name1': {'key': 'properties.name', 'type': 'str'}, + 'hourly_schedule': {'key': 'properties.hourlySchedule', 'type': 'HourlySchedule'}, + 'daily_schedule': {'key': 'properties.dailySchedule', 'type': 'DailySchedule'}, + 'weekly_schedule': {'key': 'properties.weeklySchedule', 'type': 'WeeklySchedule'}, + 'monthly_schedule': {'key': 'properties.monthlySchedule', 'type': 'MonthlySchedule'}, + 'enabled': {'key': 'properties.enabled', 'type': 'bool'}, + 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, + } + + def __init__(self, *, location: str=None, tags=None, hourly_schedule=None, daily_schedule=None, weekly_schedule=None, monthly_schedule=None, enabled: bool=None, **kwargs) -> None: + super(SnapshotPolicyPatch, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.tags = tags + self.name1 = None + self.hourly_schedule = hourly_schedule + self.daily_schedule = daily_schedule + self.weekly_schedule = weekly_schedule + self.monthly_schedule = monthly_schedule + self.enabled = enabled + self.provisioning_state = None + + +class SnapshotPolicyVolumeList(Model): + """Volumes associated with snapshot policy. + + :param value: List of volumes + :type value: list[object] + """ + + _attribute_map = { + 'value': {'key': 'value', 'type': '[object]'}, + } + + def __init__(self, *, value=None, **kwargs) -> None: + super(SnapshotPolicyVolumeList, self).__init__(**kwargs) + self.value = value + + +class Vault(Model): + """Vault information. + + Variables are only populated by the server, and will be ignored when + sending a request. + + All required parameters must be populated in order to send to Azure. + + :param location: Required. Resource location + :type location: str + :ivar id: Resource Id + :vartype id: str + :ivar name: Resource name + :vartype name: str + :ivar type: Resource type + :vartype type: str + :param vault_name: Vault Name + :type vault_name: str + """ + + _validation = { + 'location': {'required': True}, + 'id': {'readonly': True}, + 'name': {'readonly': True}, + 'type': {'readonly': True}, + } + + _attribute_map = { + 'location': {'key': 'location', 'type': 'str'}, + 'id': {'key': 'id', 'type': 'str'}, + 'name': {'key': 'name', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'vault_name': {'key': 'properties.vaultName', 'type': 'str'}, + } + + def __init__(self, *, location: str, vault_name: str=None, **kwargs) -> None: + super(Vault, self).__init__(**kwargs) + self.location = location + self.id = None + self.name = None + self.type = None + self.vault_name = vault_name + + class Volume(Model): """Volume resource. @@ -911,6 +1735,9 @@ class Volume(Model): :param snapshot_id: Snapshot ID. UUID v4 or resource identifier used to identify the Snapshot. :type snapshot_id: str + :param backup_id: Backup ID. UUID v4 or resource identifier used to + identify the Backup. + :type backup_id: str :ivar baremetal_tenant_id: Baremetal Tenant ID. Unique Baremetal Tenant Identifier. :vartype baremetal_tenant_id: str @@ -931,6 +1758,15 @@ class Volume(Model): contain a read-only .snapshot directory which provides access to each of the volume's snapshots (default to true). :type snapshot_directory_visible: bool + :param kerberos_enabled: Describe if a volume is KerberosEnabled. To be + use with swagger version 2020-05-01 or later. Default value: False . + :type kerberos_enabled: bool + :param security_style: The security style of volume. Possible values + include: 'ntfs', 'unix' + :type security_style: str or ~azure.mgmt.netapp.models.SecurityStyle + :param throughput_mibps: Maximum throughput in Mibps that can be achieved + by this volume. + :type throughput_mibps: float """ _validation = { @@ -943,8 +1779,10 @@ class Volume(Model): 'usage_threshold': {'required': True, 'maximum': 109951162777600, 'minimum': 107374182400}, 'provisioning_state': {'readonly': True}, 'snapshot_id': {'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}|(\\?([^\/]*[\/])*)([^\/]+)$'}, + 'backup_id': {'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}|(\\?([^\/]*[\/])*)([^\/]+)$'}, 'baremetal_tenant_id': {'readonly': True, 'max_length': 36, 'min_length': 36, 'pattern': r'^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$'}, 'subnet_id': {'required': True}, + 'throughput_mibps': {'maximum': 4500, 'minimum': 1, 'multiple': 0.001}, } _attribute_map = { @@ -961,6 +1799,7 @@ class Volume(Model): 'protocol_types': {'key': 'properties.protocolTypes', 'type': '[str]'}, 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, 'snapshot_id': {'key': 'properties.snapshotId', 'type': 'str'}, + 'backup_id': {'key': 'properties.backupId', 'type': 'str'}, 'baremetal_tenant_id': {'key': 'properties.baremetalTenantId', 'type': 'str'}, 'subnet_id': {'key': 'properties.subnetId', 'type': 'str'}, 'mount_targets': {'key': 'properties.mountTargets', 'type': '[MountTargetProperties]'}, @@ -968,9 +1807,12 @@ class Volume(Model): 'data_protection': {'key': 'properties.dataProtection', 'type': 'VolumePropertiesDataProtection'}, 'is_restoring': {'key': 'properties.isRestoring', 'type': 'bool'}, 'snapshot_directory_visible': {'key': 'properties.snapshotDirectoryVisible', 'type': 'bool'}, + 'kerberos_enabled': {'key': 'properties.kerberosEnabled', 'type': 'bool'}, + 'security_style': {'key': 'properties.securityStyle', 'type': 'str'}, + 'throughput_mibps': {'key': 'properties.throughputMibps', 'type': 'float'}, } - def __init__(self, *, location: str, creation_token: str, subnet_id: str, tags=None, service_level="Premium", usage_threshold: int=107374182400, export_policy=None, protocol_types=None, snapshot_id: str=None, mount_targets=None, volume_type: str=None, data_protection=None, is_restoring: bool=None, snapshot_directory_visible: bool=None, **kwargs) -> None: + def __init__(self, *, location: str, creation_token: str, subnet_id: str, tags=None, service_level="Premium", usage_threshold: int=107374182400, export_policy=None, protocol_types=None, snapshot_id: str=None, backup_id: str=None, mount_targets=None, volume_type: str=None, data_protection=None, is_restoring: bool=None, snapshot_directory_visible: bool=None, kerberos_enabled: bool=False, security_style=None, throughput_mibps: float=None, **kwargs) -> None: super(Volume, self).__init__(**kwargs) self.location = location self.id = None @@ -985,6 +1827,7 @@ def __init__(self, *, location: str, creation_token: str, subnet_id: str, tags=N self.protocol_types = protocol_types self.provisioning_state = None self.snapshot_id = snapshot_id + self.backup_id = backup_id self.baremetal_tenant_id = None self.subnet_id = subnet_id self.mount_targets = mount_targets @@ -992,6 +1835,61 @@ def __init__(self, *, location: str, creation_token: str, subnet_id: str, tags=N self.data_protection = data_protection self.is_restoring = is_restoring self.snapshot_directory_visible = snapshot_directory_visible + self.kerberos_enabled = kerberos_enabled + self.security_style = security_style + self.throughput_mibps = throughput_mibps + + +class VolumeBackupProperties(Model): + """Volume Backup Properties. + + :param backup_policy_id: Backup Policy Resource ID + :type backup_policy_id: str + :param policy_enforced: Policy Enforced + :type policy_enforced: bool + :param vault_id: Vault Resource ID + :type vault_id: str + :param backup_enabled: Backup Enabled + :type backup_enabled: bool + """ + + _attribute_map = { + 'backup_policy_id': {'key': 'backupPolicyId', 'type': 'str'}, + 'policy_enforced': {'key': 'policyEnforced', 'type': 'bool'}, + 'vault_id': {'key': 'vaultId', 'type': 'str'}, + 'backup_enabled': {'key': 'backupEnabled', 'type': 'bool'}, + } + + def __init__(self, *, backup_policy_id: str=None, policy_enforced: bool=None, vault_id: str=None, backup_enabled: bool=None, **kwargs) -> None: + super(VolumeBackupProperties, self).__init__(**kwargs) + self.backup_policy_id = backup_policy_id + self.policy_enforced = policy_enforced + self.vault_id = vault_id + self.backup_enabled = backup_enabled + + +class VolumeBackups(Model): + """Volume details using the backup policy. + + :param volume_name: Volume name + :type volume_name: str + :param backups_count: Total count of backups for volume + :type backups_count: int + :param policy_enabled: Policy enabled + :type policy_enabled: bool + """ + + _attribute_map = { + 'volume_name': {'key': 'volumeName', 'type': 'str'}, + 'backups_count': {'key': 'backupsCount', 'type': 'int'}, + 'policy_enabled': {'key': 'policyEnabled', 'type': 'bool'}, + } + + def __init__(self, *, volume_name: str=None, backups_count: int=None, policy_enabled: bool=None, **kwargs) -> None: + super(VolumeBackups, self).__init__(**kwargs) + self.volume_name = volume_name + self.backups_count = backups_count + self.policy_enabled = policy_enabled class VolumePatch(Model): @@ -1022,6 +1920,13 @@ class VolumePatch(Model): :param export_policy: exportPolicy. Set of export policy rules :type export_policy: ~azure.mgmt.netapp.models.VolumePatchPropertiesExportPolicy + :param throughput_mibps: Maximum throughput in Mibps that can be achieved + by this volume. + :type throughput_mibps: float + :param data_protection: DataProtection. DataProtection type volumes + include an object containing details of the replication + :type data_protection: + ~azure.mgmt.netapp.models.VolumePatchPropertiesDataProtection """ _validation = { @@ -1029,6 +1934,7 @@ class VolumePatch(Model): 'name': {'readonly': True}, 'type': {'readonly': True}, 'usage_threshold': {'maximum': 109951162777600, 'minimum': 107374182400}, + 'throughput_mibps': {'maximum': 4500, 'minimum': 1, 'multiple': 0.001}, } _attribute_map = { @@ -1040,9 +1946,11 @@ class VolumePatch(Model): 'service_level': {'key': 'properties.serviceLevel', 'type': 'str'}, 'usage_threshold': {'key': 'properties.usageThreshold', 'type': 'long'}, 'export_policy': {'key': 'properties.exportPolicy', 'type': 'VolumePatchPropertiesExportPolicy'}, + 'throughput_mibps': {'key': 'properties.throughputMibps', 'type': 'float'}, + 'data_protection': {'key': 'properties.dataProtection', 'type': 'VolumePatchPropertiesDataProtection'}, } - def __init__(self, *, location: str=None, tags=None, service_level="Premium", usage_threshold: int=107374182400, export_policy=None, **kwargs) -> None: + def __init__(self, *, location: str=None, tags=None, service_level="Premium", usage_threshold: int=107374182400, export_policy=None, throughput_mibps: float=None, data_protection=None, **kwargs) -> None: super(VolumePatch, self).__init__(**kwargs) self.location = location self.id = None @@ -1052,6 +1960,27 @@ def __init__(self, *, location: str=None, tags=None, service_level="Premium", us self.service_level = service_level self.usage_threshold = usage_threshold self.export_policy = export_policy + self.throughput_mibps = throughput_mibps + self.data_protection = data_protection + + +class VolumePatchPropertiesDataProtection(Model): + """DataProtection. + + DataProtection type volumes include an object containing details of the + replication. + + :param backup: Backup. Backup Properties + :type backup: ~azure.mgmt.netapp.models.VolumeBackupProperties + """ + + _attribute_map = { + 'backup': {'key': 'backup', 'type': 'VolumeBackupProperties'}, + } + + def __init__(self, *, backup=None, **kwargs) -> None: + super(VolumePatchPropertiesDataProtection, self).__init__(**kwargs) + self.backup = backup class VolumePatchPropertiesExportPolicy(Model): @@ -1078,6 +2007,8 @@ class VolumePropertiesDataProtection(Model): DataProtection type volumes include an object containing details of the replication. + :param backup: Backup. Backup Properties + :type backup: ~azure.mgmt.netapp.models.VolumeBackupProperties :param replication: Replication. Replication properties :type replication: ~azure.mgmt.netapp.models.ReplicationObject :param snapshot: Snapshot. Snapshot properties. @@ -1085,12 +2016,14 @@ class VolumePropertiesDataProtection(Model): """ _attribute_map = { + 'backup': {'key': 'backup', 'type': 'VolumeBackupProperties'}, 'replication': {'key': 'replication', 'type': 'ReplicationObject'}, 'snapshot': {'key': 'snapshot', 'type': 'VolumeSnapshotProperties'}, } - def __init__(self, *, replication=None, snapshot=None, **kwargs) -> None: + def __init__(self, *, backup=None, replication=None, snapshot=None, **kwargs) -> None: super(VolumePropertiesDataProtection, self).__init__(**kwargs) + self.backup = backup self.replication = replication self.snapshot = snapshot @@ -1143,3 +2076,39 @@ class VolumeSnapshotProperties(Model): def __init__(self, *, snapshot_policy_id: str=None, **kwargs) -> None: super(VolumeSnapshotProperties, self).__init__(**kwargs) self.snapshot_policy_id = snapshot_policy_id + + +class WeeklySchedule(Model): + """Weekly Schedule properties, make a snapshot every week at a specific day or + days. + + :param snapshots_to_keep: Weekly snapshot count to keep + :type snapshots_to_keep: int + :param day: Indicates which weekdays snapshot should be taken, accepts a + comma separated list of week day names in english + :type day: str + :param hour: Indicates which hour in UTC timezone a snapshot should be + taken + :type hour: int + :param minute: Indicates which minute snapshot should be taken + :type minute: int + :param used_bytes: Resource size in bytes, current storage usage for the + volume in bytes + :type used_bytes: long + """ + + _attribute_map = { + 'snapshots_to_keep': {'key': 'snapshotsToKeep', 'type': 'int'}, + 'day': {'key': 'day', 'type': 'str'}, + 'hour': {'key': 'hour', 'type': 'int'}, + 'minute': {'key': 'minute', 'type': 'int'}, + 'used_bytes': {'key': 'usedBytes', 'type': 'long'}, + } + + def __init__(self, *, snapshots_to_keep: int=None, day: str=None, hour: int=None, minute: int=None, used_bytes: int=None, **kwargs) -> None: + super(WeeklySchedule, self).__init__(**kwargs) + self.snapshots_to_keep = snapshots_to_keep + self.day = day + self.hour = hour + self.minute = minute + self.used_bytes = used_bytes diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_paged_models.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_paged_models.py index f56ae0307cf9..d9a696871b8f 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_paged_models.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/models/_paged_models.py @@ -77,3 +77,55 @@ class SnapshotPaged(Paged): def __init__(self, *args, **kwargs): super(SnapshotPaged, self).__init__(*args, **kwargs) +class SnapshotPolicyPaged(Paged): + """ + A paging container for iterating over a list of :class:`SnapshotPolicy ` object + """ + + _attribute_map = { + 'next_link': {'key': 'nextLink', 'type': 'str'}, + 'current_page': {'key': 'value', 'type': '[SnapshotPolicy]'} + } + + def __init__(self, *args, **kwargs): + + super(SnapshotPolicyPaged, self).__init__(*args, **kwargs) +class BackupPaged(Paged): + """ + A paging container for iterating over a list of :class:`Backup ` object + """ + + _attribute_map = { + 'next_link': {'key': 'nextLink', 'type': 'str'}, + 'current_page': {'key': 'value', 'type': '[Backup]'} + } + + def __init__(self, *args, **kwargs): + + super(BackupPaged, self).__init__(*args, **kwargs) +class BackupPolicyPaged(Paged): + """ + A paging container for iterating over a list of :class:`BackupPolicy ` object + """ + + _attribute_map = { + 'next_link': {'key': 'nextLink', 'type': 'str'}, + 'current_page': {'key': 'value', 'type': '[BackupPolicy]'} + } + + def __init__(self, *args, **kwargs): + + super(BackupPolicyPaged, self).__init__(*args, **kwargs) +class VaultPaged(Paged): + """ + A paging container for iterating over a list of :class:`Vault ` object + """ + + _attribute_map = { + 'next_link': {'key': 'nextLink', 'type': 'str'}, + 'current_page': {'key': 'value', 'type': '[Vault]'} + } + + def __init__(self, *args, **kwargs): + + super(VaultPaged, self).__init__(*args, **kwargs) diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/__init__.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/__init__.py index 4658666d5793..3a28d1ebfc0c 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/__init__.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/__init__.py @@ -15,6 +15,11 @@ from ._pools_operations import PoolsOperations from ._volumes_operations import VolumesOperations from ._snapshots_operations import SnapshotsOperations +from ._snapshot_policies_operations import SnapshotPoliciesOperations +from ._account_backups_operations import AccountBackupsOperations +from ._backups_operations import BackupsOperations +from ._backup_policies_operations import BackupPoliciesOperations +from ._vaults_operations import VaultsOperations __all__ = [ 'Operations', @@ -23,4 +28,9 @@ 'PoolsOperations', 'VolumesOperations', 'SnapshotsOperations', + 'SnapshotPoliciesOperations', + 'AccountBackupsOperations', + 'BackupsOperations', + 'BackupPoliciesOperations', + 'VaultsOperations', ] diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_account_backups_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_account_backups_operations.py new file mode 100644 index 000000000000..b0e2ce2bcaf3 --- /dev/null +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_account_backups_operations.py @@ -0,0 +1,256 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is +# regenerated. +# -------------------------------------------------------------------------- + +import uuid +from msrest.pipeline import ClientRawResponse +from msrestazure.azure_exceptions import CloudError +from msrest.polling import LROPoller, NoPolling +from msrestazure.polling.arm_polling import ARMPolling + +from .. import models + + +class AccountBackupsOperations(object): + """AccountBackupsOperations operations. + + You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute. + + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". + """ + + models = models + + def __init__(self, client, config, serializer, deserializer): + + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self.api_version = "2020-06-01" + + self.config = config + + def list( + self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config): + """List Backups for a Netapp Account. + + List all Backups for a Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: BackupsList or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.BackupsList or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.list.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('BackupsList', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/accountBackups'} + + def get( + self, resource_group_name, account_name, backup_name, custom_headers=None, raw=False, **operation_config): + """Get Backup for a Netapp Account. + + Get Backup for a Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: Backup or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.Backup or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.get.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('Backup', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/accountBackups/{backupName}'} + + + def _delete_initial( + self, resource_group_name, account_name, backup_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.delete.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.delete(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202, 204]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def delete( + self, resource_group_name, account_name, backup_name, custom_headers=None, raw=False, polling=True, **operation_config): + """Delete Backup for a Netapp Account. + + Delete Backup for a Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + account_name=account_name, + backup_name=backup_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/accountBackups/{backupName}'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_accounts_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_accounts_operations.py index c97afa4e3692..f8cd9e02b38e 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_accounts_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_accounts_operations.py @@ -27,7 +27,7 @@ class AccountsOperations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -37,7 +37,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backup_policies_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backup_policies_operations.py new file mode 100644 index 000000000000..f0fef82214a8 --- /dev/null +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backup_policies_operations.py @@ -0,0 +1,453 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is +# regenerated. +# -------------------------------------------------------------------------- + +import uuid +from msrest.pipeline import ClientRawResponse +from msrestazure.azure_exceptions import CloudError +from msrest.polling import LROPoller, NoPolling +from msrestazure.polling.arm_polling import ARMPolling + +from .. import models + + +class BackupPoliciesOperations(object): + """BackupPoliciesOperations operations. + + You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute. + + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". + """ + + models = models + + def __init__(self, client, config, serializer, deserializer): + + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self.api_version = "2020-06-01" + + self.config = config + + def list( + self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config): + """List backup policies. + + List backup policies for Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: An iterator like instance of BackupPolicy + :rtype: + ~azure.mgmt.netapp.models.BackupPolicyPaged[~azure.mgmt.netapp.models.BackupPolicy] + :raises: :class:`CloudError` + """ + def prepare_request(next_link=None): + if not next_link: + # Construct URL + url = self.list.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + else: + url = next_link + query_parameters = {} + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + return request + + def internal_paging(next_link=None): + request = prepare_request(next_link) + + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + return response + + # Deserialize response + header_dict = None + if raw: + header_dict = {} + deserialized = models.BackupPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict) + + return deserialized + list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/backupPolicies'} + + def get( + self, resource_group_name, account_name, backup_policy_name, custom_headers=None, raw=False, **operation_config): + """Get a backup Policy. + + Get a particular backup Policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_policy_name: Backup policy Name which uniquely identify + backup policy. + :type backup_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: BackupPolicy or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.BackupPolicy or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.get.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupPolicyName': self._serialize.url("backup_policy_name", backup_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('BackupPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/backupPolicies/{backupPolicyName}'} + + + def _create_initial( + self, resource_group_name, account_name, backup_policy_name, body, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.create.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupPolicyName': self._serialize.url("backup_policy_name", backup_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'BackupPolicy') + + # Construct and send request + request = self._client.put(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 201, 202]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + + if response.status_code == 200: + deserialized = self._deserialize('BackupPolicy', response) + if response.status_code == 201: + deserialized = self._deserialize('BackupPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + def create( + self, resource_group_name, account_name, backup_policy_name, body, custom_headers=None, raw=False, polling=True, **operation_config): + """Create a backup policy. + + Create a backup policy for Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_policy_name: Backup policy Name which uniquely identify + backup policy. + :type backup_policy_name: str + :param body: Backup policy object supplied in the body of the + operation. + :type body: ~azure.mgmt.netapp.models.BackupPolicy + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns BackupPolicy or + ClientRawResponse if raw==True + :rtype: + ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.netapp.models.BackupPolicy] + or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.netapp.models.BackupPolicy]] + :raises: :class:`CloudError` + """ + raw_result = self._create_initial( + resource_group_name=resource_group_name, + account_name=account_name, + backup_policy_name=backup_policy_name, + body=body, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + deserialized = self._deserialize('BackupPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + create.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/backupPolicies/{backupPolicyName}'} + + def update( + self, resource_group_name, account_name, backup_policy_name, body, custom_headers=None, raw=False, **operation_config): + """Patch a backup policy. + + Patch a backup policy for Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_policy_name: Backup policy Name which uniquely identify + backup policy. + :type backup_policy_name: str + :param body: Backup policy object supplied in the body of the + operation. + :type body: ~azure.mgmt.netapp.models.BackupPolicyPatch + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: BackupPolicy or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.BackupPolicy or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.update.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupPolicyName': self._serialize.url("backup_policy_name", backup_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'BackupPolicyPatch') + + # Construct and send request + request = self._client.patch(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('BackupPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/backupPolicies/{backupPolicyName}'} + + + def _delete_initial( + self, resource_group_name, account_name, backup_policy_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.delete.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'backupPolicyName': self._serialize.url("backup_policy_name", backup_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.delete(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202, 204]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def delete( + self, resource_group_name, account_name, backup_policy_name, custom_headers=None, raw=False, polling=True, **operation_config): + """Delete a backup policy. + + Delete backup policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param backup_policy_name: Backup policy Name which uniquely identify + backup policy. + :type backup_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + account_name=account_name, + backup_policy_name=backup_policy_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/backupPolicies/{backupPolicyName}'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backups_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backups_operations.py new file mode 100644 index 000000000000..a2384ad9d3ab --- /dev/null +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_backups_operations.py @@ -0,0 +1,495 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is +# regenerated. +# -------------------------------------------------------------------------- + +import uuid +from msrest.pipeline import ClientRawResponse +from msrestazure.azure_exceptions import CloudError +from msrest.polling import LROPoller, NoPolling +from msrestazure.polling.arm_polling import ARMPolling + +from .. import models + + +class BackupsOperations(object): + """BackupsOperations operations. + + You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute. + + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". + """ + + models = models + + def __init__(self, client, config, serializer, deserializer): + + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self.api_version = "2020-06-01" + + self.config = config + + def list( + self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, **operation_config): + """List Backups. + + List all backups for a volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: An iterator like instance of Backup + :rtype: + ~azure.mgmt.netapp.models.BackupPaged[~azure.mgmt.netapp.models.Backup] + :raises: :class:`CloudError` + """ + def prepare_request(next_link=None): + if not next_link: + # Construct URL + url = self.list.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + else: + url = next_link + query_parameters = {} + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + return request + + def internal_paging(next_link=None): + request = prepare_request(next_link) + + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + return response + + # Deserialize response + header_dict = None + if raw: + header_dict = {} + deserialized = models.BackupPaged(internal_paging, self._deserialize.dependencies, header_dict) + + return deserialized + list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/backups'} + + def get( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, custom_headers=None, raw=False, **operation_config): + """Get a backup. + + Get a particular backup of the volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: Backup or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.Backup or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.get.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('Backup', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/backups/{backupName}'} + + + def _create_initial( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, location, label=None, custom_headers=None, raw=False, **operation_config): + body = models.Backup(location=location, label=label) + + # Construct URL + url = self.create.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'Backup') + + # Construct and send request + request = self._client.put(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 201, 202]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + + if response.status_code == 200: + deserialized = self._deserialize('Backup', response) + if response.status_code == 201: + deserialized = self._deserialize('Backup', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + def create( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, location, label=None, custom_headers=None, raw=False, polling=True, **operation_config): + """Create a backup. + + Create a backup for the volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param location: Resource location + :type location: str + :param label: Label for backup + :type label: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns Backup or + ClientRawResponse if raw==True + :rtype: + ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.netapp.models.Backup] + or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.netapp.models.Backup]] + :raises: :class:`CloudError` + """ + raw_result = self._create_initial( + resource_group_name=resource_group_name, + account_name=account_name, + pool_name=pool_name, + volume_name=volume_name, + backup_name=backup_name, + location=location, + label=label, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + deserialized = self._deserialize('Backup', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + create.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/backups/{backupName}'} + + def update( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, tags=None, label=None, custom_headers=None, raw=False, **operation_config): + """Patch a backup. + + Patch a backup for the volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param tags: Resource tags + :type tags: dict[str, str] + :param label: Label for backup + :type label: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: Backup or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.Backup or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + body = None + if tags is not None or label is not None: + body = models.BackupPatch(tags=tags, label=label) + + # Construct URL + url = self.update.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + if body is not None: + body_content = self._serialize.body(body, 'BackupPatch') + else: + body_content = None + + # Construct and send request + request = self._client.patch(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('Backup', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/backups/{backupName}'} + + + def _delete_initial( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.delete.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$'), + 'backupName': self._serialize.url("backup_name", backup_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.delete(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202, 204]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def delete( + self, resource_group_name, account_name, pool_name, volume_name, backup_name, custom_headers=None, raw=False, polling=True, **operation_config): + """Delete backup. + + Delete a backup of the volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param backup_name: The name of the backup + :type backup_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + account_name=account_name, + pool_name=pool_name, + volume_name=volume_name, + backup_name=backup_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/backups/{backupName}'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_net_app_resource_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_net_app_resource_operations.py index 585564008a10..2aececcdcdfd 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_net_app_resource_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_net_app_resource_operations.py @@ -25,7 +25,7 @@ class NetAppResourceOperations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -35,7 +35,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config @@ -62,8 +62,8 @@ def check_name_availability( deserialized response :param operation_config: :ref:`Operation configuration overrides`. - :return: ResourceNameAvailability or ClientRawResponse if raw=true - :rtype: ~azure.mgmt.netapp.models.ResourceNameAvailability or + :return: CheckAvailabilityResponse or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.CheckAvailabilityResponse or ~msrest.pipeline.ClientRawResponse :raises: :class:`CloudError` """ @@ -106,7 +106,7 @@ def check_name_availability( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ResourceNameAvailability', response) + deserialized = self._deserialize('CheckAvailabilityResponse', response) if raw: client_raw_response = ClientRawResponse(deserialized, response) @@ -138,8 +138,8 @@ def check_file_path_availability( deserialized response :param operation_config: :ref:`Operation configuration overrides`. - :return: ResourceNameAvailability or ClientRawResponse if raw=true - :rtype: ~azure.mgmt.netapp.models.ResourceNameAvailability or + :return: CheckAvailabilityResponse or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.CheckAvailabilityResponse or ~msrest.pipeline.ClientRawResponse :raises: :class:`CloudError` """ @@ -182,7 +182,7 @@ def check_file_path_availability( deserialized = None if response.status_code == 200: - deserialized = self._deserialize('ResourceNameAvailability', response) + deserialized = self._deserialize('CheckAvailabilityResponse', response) if raw: client_raw_response = ClientRawResponse(deserialized, response) @@ -190,3 +190,80 @@ def check_file_path_availability( return deserialized check_file_path_availability.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.NetApp/locations/{location}/checkFilePathAvailability'} + + def check_quota_availability( + self, location, name, type, resource_group, custom_headers=None, raw=False, **operation_config): + """Check quota availability. + + Check if a quota is available. + + :param location: The location + :type location: str + :param name: Name of the resource to verify. + :type name: str + :param type: Resource type used for verification. Possible values + include: 'Microsoft.NetApp/netAppAccounts', + 'Microsoft.NetApp/netAppAccounts/capacityPools', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes', + 'Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots' + :type type: str or + ~azure.mgmt.netapp.models.CheckQuotaNameResourceTypes + :param resource_group: Resource group name. + :type resource_group: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: CheckAvailabilityResponse or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.CheckAvailabilityResponse or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + body = models.QuotaAvailabilityRequest(name=name, type=type, resource_group=resource_group) + + # Construct URL + url = self.check_quota_availability.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'location': self._serialize.url("location", location, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'QuotaAvailabilityRequest') + + # Construct and send request + request = self._client.post(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('CheckAvailabilityResponse', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + check_quota_availability.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.NetApp/locations/{location}/checkQuotaAvailability'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_operations.py index 346d5d8f058d..a4381f64f8e2 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_operations.py @@ -25,7 +25,7 @@ class Operations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -35,7 +35,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_pools_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_pools_operations.py index f55569ece678..971eaa069837 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_pools_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_pools_operations.py @@ -27,7 +27,7 @@ class PoolsOperations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -37,7 +37,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshot_policies_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshot_policies_operations.py new file mode 100644 index 000000000000..24e5d178509c --- /dev/null +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshot_policies_operations.py @@ -0,0 +1,505 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is +# regenerated. +# -------------------------------------------------------------------------- + +import uuid +from msrest.pipeline import ClientRawResponse +from msrestazure.azure_exceptions import CloudError +from msrest.polling import LROPoller, NoPolling +from msrestazure.polling.arm_polling import ARMPolling + +from .. import models + + +class SnapshotPoliciesOperations(object): + """SnapshotPoliciesOperations operations. + + You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute. + + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". + """ + + models = models + + def __init__(self, client, config, serializer, deserializer): + + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self.api_version = "2020-06-01" + + self.config = config + + def list( + self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config): + """List snapshot policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: An iterator like instance of SnapshotPolicy + :rtype: + ~azure.mgmt.netapp.models.SnapshotPolicyPaged[~azure.mgmt.netapp.models.SnapshotPolicy] + :raises: :class:`CloudError` + """ + def prepare_request(next_link=None): + if not next_link: + # Construct URL + url = self.list.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + else: + url = next_link + query_parameters = {} + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + return request + + def internal_paging(next_link=None): + request = prepare_request(next_link) + + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + return response + + # Deserialize response + header_dict = None + if raw: + header_dict = {} + deserialized = models.SnapshotPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict) + + return deserialized + list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies'} + + def get( + self, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, **operation_config): + """Get a snapshot Policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param snapshot_policy_name: The name of the snapshot policy target + :type snapshot_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: SnapshotPolicy or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.SnapshotPolicy or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.get.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'snapshotPolicyName': self._serialize.url("snapshot_policy_name", snapshot_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('SnapshotPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies/{snapshotPolicyName}'} + + + def _create_initial( + self, body, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.create.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'snapshotPolicyName': self._serialize.url("snapshot_policy_name", snapshot_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'SnapshotPolicy') + + # Construct and send request + request = self._client.put(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 201]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + + if response.status_code == 200: + deserialized = self._deserialize('SnapshotPolicy', response) + if response.status_code == 201: + deserialized = self._deserialize('SnapshotPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + def create( + self, body, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, polling=True, **operation_config): + """Create a snapshot policy. + + :param body: Snapshot policy object supplied in the body of the + operation. + :type body: ~azure.mgmt.netapp.models.SnapshotPolicy + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param snapshot_policy_name: The name of the snapshot policy target + :type snapshot_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns SnapshotPolicy or + ClientRawResponse if raw==True + :rtype: + ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.netapp.models.SnapshotPolicy] + or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.netapp.models.SnapshotPolicy]] + :raises: :class:`CloudError` + """ + raw_result = self._create_initial( + body=body, + resource_group_name=resource_group_name, + account_name=account_name, + snapshot_policy_name=snapshot_policy_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + deserialized = self._deserialize('SnapshotPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + create.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies/{snapshotPolicyName}'} + + def update( + self, body, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, **operation_config): + """Patch a snapshot policy. + + :param body: Snapshot policy object supplied in the body of the + operation. + :type body: ~azure.mgmt.netapp.models.SnapshotPolicyPatch + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param snapshot_policy_name: The name of the snapshot policy target + :type snapshot_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: SnapshotPolicy or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.SnapshotPolicy or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.update.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'snapshotPolicyName': self._serialize.url("snapshot_policy_name", snapshot_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'SnapshotPolicyPatch') + + # Construct and send request + request = self._client.patch(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('SnapshotPolicy', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies/{snapshotPolicyName}'} + + + def _delete_initial( + self, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.delete.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'snapshotPolicyName': self._serialize.url("snapshot_policy_name", snapshot_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.delete(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202, 204]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def delete( + self, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, polling=True, **operation_config): + """Delete snapshot policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param snapshot_policy_name: The name of the snapshot policy target + :type snapshot_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._delete_initial( + resource_group_name=resource_group_name, + account_name=account_name, + snapshot_policy_name=snapshot_policy_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies/{snapshotPolicyName}'} + + def list_volumes( + self, resource_group_name, account_name, snapshot_policy_name, custom_headers=None, raw=False, **operation_config): + """Get volumes associated with snapshot policy. + + Get volumes associated with snapshot policy. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param snapshot_policy_name: The name of the snapshot policy target + :type snapshot_policy_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: SnapshotPolicyVolumeList or ClientRawResponse if raw=true + :rtype: ~azure.mgmt.netapp.models.SnapshotPolicyVolumeList or + ~msrest.pipeline.ClientRawResponse + :raises: :class:`CloudError` + """ + # Construct URL + url = self.list_volumes.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'snapshotPolicyName': self._serialize.url("snapshot_policy_name", snapshot_policy_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize('SnapshotPolicyVolumeList', response) + + if raw: + client_raw_response = ClientRawResponse(deserialized, response) + return client_raw_response + + return deserialized + list_volumes.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/snapshotPolicies/{snapshotPolicyName}/listVolumes'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshots_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshots_operations.py index efce67ecfc07..1954b08ae2a7 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshots_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_snapshots_operations.py @@ -27,7 +27,7 @@ class SnapshotsOperations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -37,7 +37,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_vaults_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_vaults_operations.py new file mode 100644 index 000000000000..079de31514ac --- /dev/null +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_vaults_operations.py @@ -0,0 +1,114 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for +# license information. +# +# Code generated by Microsoft (R) AutoRest Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is +# regenerated. +# -------------------------------------------------------------------------- + +import uuid +from msrest.pipeline import ClientRawResponse +from msrestazure.azure_exceptions import CloudError + +from .. import models + + +class VaultsOperations(object): + """VaultsOperations operations. + + You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute. + + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". + """ + + models = models + + def __init__(self, client, config, serializer, deserializer): + + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self.api_version = "2020-06-01" + + self.config = config + + def list( + self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config): + """List vaults. + + List vaults for a Netapp Account. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: returns the direct response alongside the + deserialized response + :param operation_config: :ref:`Operation configuration + overrides`. + :return: An iterator like instance of Vault + :rtype: + ~azure.mgmt.netapp.models.VaultPaged[~azure.mgmt.netapp.models.Vault] + :raises: :class:`CloudError` + """ + def prepare_request(next_link=None): + if not next_link: + # Construct URL + url = self.list.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + else: + url = next_link + query_parameters = {} + + # Construct headers + header_parameters = {} + header_parameters['Accept'] = 'application/json' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.get(url, query_parameters, header_parameters) + return request + + def internal_paging(next_link=None): + request = prepare_request(next_link) + + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + return response + + # Deserialize response + header_dict = None + if raw: + header_dict = {} + deserialized = models.VaultPaged(internal_paging, self._deserialize.dependencies, header_dict) + + return deserialized + list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/vaults'} diff --git a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_volumes_operations.py b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_volumes_operations.py index c38982b89a93..7a819a458c3d 100644 --- a/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_volumes_operations.py +++ b/sdk/netapp/azure-mgmt-netapp/azure/mgmt/netapp/operations/_volumes_operations.py @@ -27,7 +27,7 @@ class VolumesOperations(object): :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. - :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-02-01". + :ivar api_version: Version of the API to be used with the client request. Constant value: "2020-06-01". """ models = models @@ -37,7 +37,7 @@ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer - self.api_version = "2020-02-01" + self.api_version = "2020-06-01" self.config = config @@ -598,7 +598,11 @@ def get_long_running_output(response): def _break_replication_initial( - self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, **operation_config): + self, resource_group_name, account_name, pool_name, volume_name, force_break_replication=None, custom_headers=None, raw=False, **operation_config): + body = None + if force_break_replication is not None: + body = models.BreakReplicationRequest(force_break_replication=force_break_replication) + # Construct URL url = self.break_replication.metadata['url'] path_format_arguments = { @@ -616,6 +620,7 @@ def _break_replication_initial( # Construct headers header_parameters = {} + header_parameters['Content-Type'] = 'application/json; charset=utf-8' if self.config.generate_client_request_id: header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) if custom_headers: @@ -623,8 +628,14 @@ def _break_replication_initial( if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + # Construct body + if body is not None: + body_content = self._serialize.body(body, 'BreakReplicationRequest') + else: + body_content = None + # Construct and send request - request = self._client.post(url, query_parameters, header_parameters) + request = self._client.post(url, query_parameters, header_parameters, body_content) response = self._client.send(request, stream=False, **operation_config) if response.status_code not in [200, 202]: @@ -637,7 +648,7 @@ def _break_replication_initial( return client_raw_response def break_replication( - self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, polling=True, **operation_config): + self, resource_group_name, account_name, pool_name, volume_name, force_break_replication=None, custom_headers=None, raw=False, polling=True, **operation_config): """Break volume replication. Break the replication connection on the destination volume. @@ -650,6 +661,9 @@ def break_replication( :type pool_name: str :param volume_name: The name of the volume :type volume_name: str + :param force_break_replication: If replication is in status + transferring and you want to force break the replication, set to true + :type force_break_replication: bool :param dict custom_headers: headers that will be added to the request :param bool raw: The poller return type is ClientRawResponse, the direct response alongside the deserialized response @@ -666,6 +680,7 @@ def break_replication( account_name=account_name, pool_name=pool_name, volume_name=volume_name, + force_break_replication=force_break_replication, custom_headers=custom_headers, raw=True, **operation_config @@ -1032,3 +1047,190 @@ def get_long_running_output(response): else: polling_method = polling return LROPoller(self._client, raw_result, get_long_running_output, polling_method) authorize_replication.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/authorizeReplication'} + + + def _re_initialize_replication_initial( + self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, **operation_config): + # Construct URL + url = self.re_initialize_replication.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct and send request + request = self._client.post(url, query_parameters, header_parameters) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def re_initialize_replication( + self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, polling=True, **operation_config): + """ReInitialize volume replication. + + Re-Initializes the replication connection on the destination volume. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._re_initialize_replication_initial( + resource_group_name=resource_group_name, + account_name=account_name, + pool_name=pool_name, + volume_name=volume_name, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + re_initialize_replication.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/reinitializeReplication'} + + + def _pool_change_initial( + self, resource_group_name, account_name, pool_name, volume_name, new_pool_resource_id, custom_headers=None, raw=False, **operation_config): + body = models.PoolChangeRequest(new_pool_resource_id=new_pool_resource_id) + + # Construct URL + url = self.pool_change.metadata['url'] + path_format_arguments = { + 'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'), + 'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'), + 'accountName': self._serialize.url("account_name", account_name, 'str'), + 'poolName': self._serialize.url("pool_name", pool_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]{0,63}$'), + 'volumeName': self._serialize.url("volume_name", volume_name, 'str', max_length=64, min_length=1, pattern=r'^[a-zA-Z][a-zA-Z0-9\-_]{0,63}$') + } + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} + query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str') + + # Construct headers + header_parameters = {} + header_parameters['Content-Type'] = 'application/json; charset=utf-8' + if self.config.generate_client_request_id: + header_parameters['x-ms-client-request-id'] = str(uuid.uuid1()) + if custom_headers: + header_parameters.update(custom_headers) + if self.config.accept_language is not None: + header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') + + # Construct body + body_content = self._serialize.body(body, 'PoolChangeRequest') + + # Construct and send request + request = self._client.post(url, query_parameters, header_parameters, body_content) + response = self._client.send(request, stream=False, **operation_config) + + if response.status_code not in [200, 202]: + exp = CloudError(response) + exp.request_id = response.headers.get('x-ms-request-id') + raise exp + + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + def pool_change( + self, resource_group_name, account_name, pool_name, volume_name, new_pool_resource_id, custom_headers=None, raw=False, polling=True, **operation_config): + """Change pool for volume. + + Moves volume to another pool. + + :param resource_group_name: The name of the resource group. + :type resource_group_name: str + :param account_name: The name of the NetApp account + :type account_name: str + :param pool_name: The name of the capacity pool + :type pool_name: str + :param volume_name: The name of the volume + :type volume_name: str + :param new_pool_resource_id: Resource id of the pool to move volume to + :type new_pool_resource_id: str + :param dict custom_headers: headers that will be added to the request + :param bool raw: The poller return type is ClientRawResponse, the + direct response alongside the deserialized response + :param polling: True for ARMPolling, False for no polling, or a + polling object for personal polling strategy + :return: An instance of LROPoller that returns None or + ClientRawResponse if raw==True + :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or + ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]] + :raises: :class:`CloudError` + """ + raw_result = self._pool_change_initial( + resource_group_name=resource_group_name, + account_name=account_name, + pool_name=pool_name, + volume_name=volume_name, + new_pool_resource_id=new_pool_resource_id, + custom_headers=custom_headers, + raw=True, + **operation_config + ) + + def get_long_running_output(response): + if raw: + client_raw_response = ClientRawResponse(None, response) + return client_raw_response + + lro_delay = operation_config.get( + 'long_running_operation_timeout', + self.config.long_running_operation_timeout) + if polling is True: polling_method = ARMPolling(lro_delay, **operation_config) + elif polling is False: polling_method = NoPolling() + else: polling_method = polling + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + pool_change.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}/capacityPools/{poolName}/volumes/{volumeName}/poolChange'} diff --git a/sdk/netapp/azure-mgmt-netapp/setup.py b/sdk/netapp/azure-mgmt-netapp/setup.py index 70a740cc9512..fe278800efe4 100644 --- a/sdk/netapp/azure-mgmt-netapp/setup.py +++ b/sdk/netapp/azure-mgmt-netapp/setup.py @@ -36,7 +36,7 @@ pass # Version extraction inspired from 'requests' -with open(os.path.join(package_folder_path, 'version.py') +with open(os.path.join(package_folder_path, 'version.py') if os.path.exists(os.path.join(package_folder_path, 'version.py')) else os.path.join(package_folder_path, '_version.py'), 'r') as fd: version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]',