[AutoPR] storage/resource-manager

sdk/storage/azure-mgmt-storage/HISTORY.rst

@@ -3,6 +3,17 @@
 Release History
 ===============
 
+5.0.0 (2019-10-21)
+++++++++++++++++++
+
+**Features**
+
+- Model AzureFilesIdentityBasedAuthentication has a new parameter active_directory_properties
+
+**Breaking changes**
+
+- Operation StorageAccountsOperations.list_keys has a new signature
+
 4.2.0 (2019-10-07)
 ++++++++++++++++++
 

sdk/storage/azure-mgmt-storage/azure/mgmt/storage/_storage_management_client.py

@@ -46,7 +46,7 @@ class StorageManagementClient(MultiApiClientMixin, SDKClient):
     :type profile: azure.profiles.KnownProfiles
     """
 
-    DEFAULT_API_VERSION = '2019-04-01'
+    DEFAULT_API_VERSION = '2019-06-01'
     _PROFILE_TAG = "azure.mgmt.storage.StorageManagementClient"
     LATEST_PROFILE = ProfileDefinition({
         _PROFILE_TAG: {
@@ -83,6 +83,7 @@ def models(cls, api_version=DEFAULT_API_VERSION):
            * 2018-07-01: :mod:`v2018_07_01.models<azure.mgmt.storage.v2018_07_01.models>`
            * 2018-11-01: :mod:`v2018_11_01.models<azure.mgmt.storage.v2018_11_01.models>`
            * 2019-04-01: :mod:`v2019_04_01.models<azure.mgmt.storage.v2019_04_01.models>`
+           * 2019-06-01: :mod:`v2019_06_01.models<azure.mgmt.storage.v2019_06_01.models>`
         """
         if api_version == '2015-06-15':
             from .v2015_06_15 import models
@@ -114,6 +115,9 @@ def models(cls, api_version=DEFAULT_API_VERSION):
         elif api_version == '2019-04-01':
             from .v2019_04_01 import models
             return models
+        elif api_version == '2019-06-01':
+            from .v2019_06_01 import models
+            return models
         raise NotImplementedError("APIVersion {} is not available".format(api_version))
 
     @property
@@ -125,6 +129,7 @@ def blob_containers(self):
            * 2018-07-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2018_07_01.operations.BlobContainersOperations>`
            * 2018-11-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2018_11_01.operations.BlobContainersOperations>`
            * 2019-04-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2019_04_01.operations.BlobContainersOperations>`
+           * 2019-06-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2019_06_01.operations.BlobContainersOperations>`
         """
         api_version = self._get_api_version('blob_containers')
         if api_version == '2018-02-01':
@@ -137,6 +142,8 @@ def blob_containers(self):
             from .v2018_11_01.operations import BlobContainersOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import BlobContainersOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import BlobContainersOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -148,6 +155,7 @@ def blob_services(self):
            * 2018-07-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2018_07_01.operations.BlobServicesOperations>`
            * 2018-11-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2018_11_01.operations.BlobServicesOperations>`
            * 2019-04-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2019_04_01.operations.BlobServicesOperations>`
+           * 2019-06-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2019_06_01.operations.BlobServicesOperations>`
         """
         api_version = self._get_api_version('blob_services')
         if api_version == '2018-07-01':
@@ -156,6 +164,8 @@ def blob_services(self):
             from .v2018_11_01.operations import BlobServicesOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import BlobServicesOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import BlobServicesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -165,10 +175,13 @@ def file_services(self):
         """Instance depends on the API version:
 
            * 2019-04-01: :class:`FileServicesOperations<azure.mgmt.storage.v2019_04_01.operations.FileServicesOperations>`
+           * 2019-06-01: :class:`FileServicesOperations<azure.mgmt.storage.v2019_06_01.operations.FileServicesOperations>`
         """
         api_version = self._get_api_version('file_services')
         if api_version == '2019-04-01':
             from .v2019_04_01.operations import FileServicesOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import FileServicesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -178,10 +191,13 @@ def file_shares(self):
         """Instance depends on the API version:
 
            * 2019-04-01: :class:`FileSharesOperations<azure.mgmt.storage.v2019_04_01.operations.FileSharesOperations>`
+           * 2019-06-01: :class:`FileSharesOperations<azure.mgmt.storage.v2019_06_01.operations.FileSharesOperations>`
         """
         api_version = self._get_api_version('file_shares')
         if api_version == '2019-04-01':
             from .v2019_04_01.operations import FileSharesOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import FileSharesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -193,6 +209,7 @@ def management_policies(self):
            * 2018-07-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_07_01.operations.ManagementPoliciesOperations>`
            * 2018-11-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_11_01.operations.ManagementPoliciesOperations>`
            * 2019-04-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_04_01.operations.ManagementPoliciesOperations>`
+           * 2019-06-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_06_01.operations.ManagementPoliciesOperations>`
         """
         api_version = self._get_api_version('management_policies')
         if api_version == '2018-07-01':
@@ -201,6 +218,8 @@ def management_policies(self):
             from .v2018_11_01.operations import ManagementPoliciesOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import ManagementPoliciesOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import ManagementPoliciesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -216,6 +235,7 @@ def operations(self):
            * 2018-07-01: :class:`Operations<azure.mgmt.storage.v2018_07_01.operations.Operations>`
            * 2018-11-01: :class:`Operations<azure.mgmt.storage.v2018_11_01.operations.Operations>`
            * 2019-04-01: :class:`Operations<azure.mgmt.storage.v2019_04_01.operations.Operations>`
+           * 2019-06-01: :class:`Operations<azure.mgmt.storage.v2019_06_01.operations.Operations>`
         """
         api_version = self._get_api_version('operations')
         if api_version == '2017-06-01':
@@ -232,6 +252,34 @@ def operations(self):
             from .v2018_11_01.operations import Operations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import Operations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import Operations as OperationClass
+        else:
+            raise NotImplementedError("APIVersion {} is not available".format(api_version))
+        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
+
+    @property
+    def private_endpoint_connections(self):
+        """Instance depends on the API version:
+
+           * 2019-06-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2019_06_01.operations.PrivateEndpointConnectionsOperations>`
+        """
+        api_version = self._get_api_version('private_endpoint_connections')
+        if api_version == '2019-06-01':
+            from .v2019_06_01.operations import PrivateEndpointConnectionsOperations as OperationClass
+        else:
+            raise NotImplementedError("APIVersion {} is not available".format(api_version))
+        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
+
+    @property
+    def private_link_resources(self):
+        """Instance depends on the API version:
+
+           * 2019-06-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2019_06_01.operations.PrivateLinkResourcesOperations>`
+        """
+        api_version = self._get_api_version('private_link_resources')
+        if api_version == '2019-06-01':
+            from .v2019_06_01.operations import PrivateLinkResourcesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -247,6 +295,7 @@ def skus(self):
            * 2018-07-01: :class:`SkusOperations<azure.mgmt.storage.v2018_07_01.operations.SkusOperations>`
            * 2018-11-01: :class:`SkusOperations<azure.mgmt.storage.v2018_11_01.operations.SkusOperations>`
            * 2019-04-01: :class:`SkusOperations<azure.mgmt.storage.v2019_04_01.operations.SkusOperations>`
+           * 2019-06-01: :class:`SkusOperations<azure.mgmt.storage.v2019_06_01.operations.SkusOperations>`
         """
         api_version = self._get_api_version('skus')
         if api_version == '2017-06-01':
@@ -263,6 +312,8 @@ def skus(self):
             from .v2018_11_01.operations import SkusOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import SkusOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import SkusOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -281,6 +332,7 @@ def storage_accounts(self):
            * 2018-07-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2018_07_01.operations.StorageAccountsOperations>`
            * 2018-11-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2018_11_01.operations.StorageAccountsOperations>`
            * 2019-04-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2019_04_01.operations.StorageAccountsOperations>`
+           * 2019-06-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2019_06_01.operations.StorageAccountsOperations>`
         """
         api_version = self._get_api_version('storage_accounts')
         if api_version == '2015-06-15':
@@ -303,6 +355,8 @@ def storage_accounts(self):
             from .v2018_11_01.operations import StorageAccountsOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import StorageAccountsOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import StorageAccountsOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@@ -343,6 +397,7 @@ def usages(self):
            * 2018-07-01: :class:`UsagesOperations<azure.mgmt.storage.v2018_07_01.operations.UsagesOperations>`
            * 2018-11-01: :class:`UsagesOperations<azure.mgmt.storage.v2018_11_01.operations.UsagesOperations>`
            * 2019-04-01: :class:`UsagesOperations<azure.mgmt.storage.v2019_04_01.operations.UsagesOperations>`
+           * 2019-06-01: :class:`UsagesOperations<azure.mgmt.storage.v2019_06_01.operations.UsagesOperations>`
         """
         api_version = self._get_api_version('usages')
         if api_version == '2018-03-01-preview':
@@ -353,6 +408,8 @@ def usages(self):
             from .v2018_11_01.operations import UsagesOperations as OperationClass
         elif api_version == '2019-04-01':
             from .v2019_04_01.operations import UsagesOperations as OperationClass
+        elif api_version == '2019-06-01':
+            from .v2019_06_01.operations import UsagesOperations as OperationClass
         else:
             raise NotImplementedError("APIVersion {} is not available".format(api_version))
         return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))

sdk/storage/azure-mgmt-storage/azure/mgmt/storage/models.py

@@ -5,4 +5,4 @@
 # license information.
 # --------------------------------------------------------------------------
 from .v2018_02_01.models import *
-from .v2019_04_01.models import *
+from .v2019_06_01.models import *

sdk/storage/azure-mgmt-storage/azure/mgmt/storage/v2019_04_01/models/__init__.py

@@ -11,6 +11,7 @@
 
 try:
     from ._models_py3 import AccountSasParameters
+    from ._models_py3 import ActiveDirectoryProperties
     from ._models_py3 import AzureEntityResource
     from ._models_py3 import AzureFilesIdentityBasedAuthentication
     from ._models_py3 import BlobContainer
@@ -79,6 +80,7 @@
     from ._models_py3 import VirtualNetworkRule
 except (SyntaxError, ImportError):
     from ._models import AccountSasParameters
+    from ._models import ActiveDirectoryProperties
     from ._models import AzureEntityResource
     from ._models import AzureFilesIdentityBasedAuthentication
     from ._models import BlobContainer
@@ -183,10 +185,12 @@
     ImmutabilityPolicyState,
     ImmutabilityPolicyUpdateType,
     StorageAccountExpand,
+    ListKeyExpand,
 )
 
 __all__ = [
     'AccountSasParameters',
+    'ActiveDirectoryProperties',
     'AzureEntityResource',
     'AzureFilesIdentityBasedAuthentication',
     'BlobContainer',
@@ -290,4 +294,5 @@
     'ImmutabilityPolicyState',
     'ImmutabilityPolicyUpdateType',
     'StorageAccountExpand',
+    'ListKeyExpand',
 ]

sdk/storage/azure-mgmt-storage/azure/mgmt/storage/v2019_04_01/models/_models.py

@@ -81,6 +81,56 @@ def __init__(self, **kwargs):
         self.key_to_sign = kwargs.get('key_to_sign', None)
 
 
+class ActiveDirectoryProperties(Model):
+    """Settings properties for Active Directory (AD).
+
+    All required parameters must be populated in order to send to Azure.
+
+    :param domain_name: Required. Specifies the primary domain that the AD DNS
+     server is authoritative for.
+    :type domain_name: str
+    :param net_bios_domain_name: Required. Specifies the NetBIOS domain name.
+    :type net_bios_domain_name: str
+    :param forest_name: Required. Specifies the Active Directory forest to
+     get.
+    :type forest_name: str
+    :param domain_guid: Required. Specifies the domain GUID.
+    :type domain_guid: str
+    :param domain_sid: Required. Specifies the security identifier (SID).
+    :type domain_sid: str
+    :param azure_storage_sid: Required. Specifies the security identifier
+     (SID) for Azure Storage.
+    :type azure_storage_sid: str
+    """
+
+    _validation = {
+        'domain_name': {'required': True},
+        'net_bios_domain_name': {'required': True},
+        'forest_name': {'required': True},
+        'domain_guid': {'required': True},
+        'domain_sid': {'required': True},
+        'azure_storage_sid': {'required': True},
+    }
+
+    _attribute_map = {
+        'domain_name': {'key': 'domainName', 'type': 'str'},
+        'net_bios_domain_name': {'key': 'netBiosDomainName', 'type': 'str'},
+        'forest_name': {'key': 'forestName', 'type': 'str'},
+        'domain_guid': {'key': 'domainGuid', 'type': 'str'},
+        'domain_sid': {'key': 'domainSid', 'type': 'str'},
+        'azure_storage_sid': {'key': 'azureStorageSid', 'type': 'str'},
+    }
+
+    def __init__(self, **kwargs):
+        super(ActiveDirectoryProperties, self).__init__(**kwargs)
+        self.domain_name = kwargs.get('domain_name', None)
+        self.net_bios_domain_name = kwargs.get('net_bios_domain_name', None)
+        self.forest_name = kwargs.get('forest_name', None)
+        self.domain_guid = kwargs.get('domain_guid', None)
+        self.domain_sid = kwargs.get('domain_sid', None)
+        self.azure_storage_sid = kwargs.get('azure_storage_sid', None)
+
+
 class Resource(Model):
     """Resource.
 
@@ -160,9 +210,12 @@ class AzureFilesIdentityBasedAuthentication(Model):
     All required parameters must be populated in order to send to Azure.
 
     :param directory_service_options: Required. Indicates the directory
-     service used. Possible values include: 'None', 'AADDS'
+     service used. Possible values include: 'None', 'AADDS', 'AD'
     :type directory_service_options: str or
      ~azure.mgmt.storage.v2019_04_01.models.DirectoryServiceOptions
+    :param active_directory_properties: Required if choose AD.
+    :type active_directory_properties:
+     ~azure.mgmt.storage.v2019_04_01.models.ActiveDirectoryProperties
     """
 
     _validation = {
@@ -171,11 +224,13 @@ class AzureFilesIdentityBasedAuthentication(Model):
 
     _attribute_map = {
         'directory_service_options': {'key': 'directoryServiceOptions', 'type': 'str'},
+        'active_directory_properties': {'key': 'activeDirectoryProperties', 'type': 'ActiveDirectoryProperties'},
     }
 
     def __init__(self, **kwargs):
         super(AzureFilesIdentityBasedAuthentication, self).__init__(**kwargs)
         self.directory_service_options = kwargs.get('directory_service_options', None)
+        self.active_directory_properties = kwargs.get('active_directory_properties', None)
 
 
 class BlobContainer(AzureEntityResource):
@@ -2610,7 +2665,7 @@ class StorageAccountRegenerateKeyParameters(Model):
     All required parameters must be populated in order to send to Azure.
 
     :param key_name: Required. The name of storage keys that want to be
-     regenerated, possible values are key1, key2.
+     regenerated, possible values are key1, key2, kerb1, kerb2.
     :type key_name: str
     """