Peering 2019-09-01-preview (#8172)

* peering 2019-09-01-preview

* add peering test

* fix recording file location

* changelog

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

@@ -3,6 +3,13 @@
 Release History
 ===============
 
+0.1.0rc2 (2019-10-24)
++++++++++++++++++++++
+
+**Breaking changes**
+
+- Migrated operations from PeeringServicePrefixesOperations to PrefixesOperations
+
 0.1.0rc1 (2019-09-26)
 +++++++++++++++++++++
 

sdk/peering/azure-mgmt-peering/azure/mgmt/peering/_peering_management_client.py

@@ -20,7 +20,6 @@
 from .operations import PeeringLocationsOperations
 from .operations import PeeringsOperations
 from .operations import PeeringServiceLocationsOperations
-from .operations import PeeringServicePrefixesOperations
 from .operations import PrefixesOperations
 from .operations import PeeringServiceProvidersOperations
 from .operations import PeeringServicesOperations
@@ -45,8 +44,6 @@ class PeeringManagementClient(PeeringManagementClientOperationsMixin, SDKClient)
     :vartype peerings: azure.mgmt.peering.operations.PeeringsOperations
     :ivar peering_service_locations: PeeringServiceLocations operations
     :vartype peering_service_locations: azure.mgmt.peering.operations.PeeringServiceLocationsOperations
-    :ivar peering_service_prefixes: PeeringServicePrefixes operations
-    :vartype peering_service_prefixes: azure.mgmt.peering.operations.PeeringServicePrefixesOperations
     :ivar prefixes: Prefixes operations
     :vartype prefixes: azure.mgmt.peering.operations.PrefixesOperations
     :ivar peering_service_providers: PeeringServiceProviders operations
@@ -69,7 +66,7 @@ def __init__(
         super(PeeringManagementClient, 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 = '2019-08-01-preview'
+        self.api_version = '2019-09-01-preview'
         self._serialize = Serializer(client_models)
         self._deserialize = Deserializer(client_models)
 
@@ -85,8 +82,6 @@ def __init__(
             self._client, self.config, self._serialize, self._deserialize)
         self.peering_service_locations = PeeringServiceLocationsOperations(
             self._client, self.config, self._serialize, self._deserialize)
-        self.peering_service_prefixes = PeeringServicePrefixesOperations(
-            self._client, self.config, self._serialize, self._deserialize)
         self.prefixes = PrefixesOperations(
             self._client, self.config, self._serialize, self._deserialize)
         self.peering_service_providers = PeeringServiceProvidersOperations(

sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/__init__.py

@@ -31,6 +31,7 @@
     from ._models_py3 import PeeringService
     from ._models_py3 import PeeringServiceLocation
     from ._models_py3 import PeeringServicePrefix
+    from ._models_py3 import PeeringServicePrefixEvent
     from ._models_py3 import PeeringServiceProvider
     from ._models_py3 import PeeringSku
     from ._models_py3 import Resource
@@ -58,6 +59,7 @@
     from ._models import PeeringService
     from ._models import PeeringServiceLocation
     from ._models import PeeringServicePrefix
+    from ._models import PeeringServicePrefixEvent
     from ._models import PeeringServiceProvider
     from ._models import PeeringSku
     from ._models import Resource
@@ -110,6 +112,7 @@
     'PeeringService',
     'PeeringServiceLocation',
     'PeeringServicePrefix',
+    'PeeringServicePrefixEvent',
     'PeeringServiceProvider',
     'PeeringSku',
     'Resource',

sdk/peering/azure-mgmt-peering/azure/mgmt/peering/models/_models.py

@@ -149,9 +149,9 @@ class DirectConnection(Model):
 
     :param bandwidth_in_mbps: The bandwidth of the connection.
     :type bandwidth_in_mbps: int
-    :param provisioned_bandwidth_in_mbps: The bandwidth that is actually
+    :ivar provisioned_bandwidth_in_mbps: The bandwidth that is actually
      provisioned.
-    :type provisioned_bandwidth_in_mbps: int
+    :vartype provisioned_bandwidth_in_mbps: int
     :param session_address_provider: The field indicating if Microsoft
      provides session ip addresses. Possible values include: 'Microsoft',
      'Peer'
@@ -173,10 +173,15 @@ class DirectConnection(Model):
     :param connection_identifier: The unique identifier (GUID) for the
      connection.
     :type connection_identifier: str
+    :ivar error_message: The error message related to the connection state, if
+     any.
+    :vartype error_message: str
     """
 
     _validation = {
+        'provisioned_bandwidth_in_mbps': {'readonly': True},
         'connection_state': {'readonly': True},
+        'error_message': {'readonly': True},
     }
 
     _attribute_map = {
@@ -188,18 +193,20 @@ class DirectConnection(Model):
         'connection_state': {'key': 'connectionState', 'type': 'str'},
         'bgp_session': {'key': 'bgpSession', 'type': 'BgpSession'},
         'connection_identifier': {'key': 'connectionIdentifier', 'type': 'str'},
+        'error_message': {'key': 'errorMessage', 'type': 'str'},
     }
 
     def __init__(self, **kwargs):
         super(DirectConnection, self).__init__(**kwargs)
         self.bandwidth_in_mbps = kwargs.get('bandwidth_in_mbps', None)
-        self.provisioned_bandwidth_in_mbps = kwargs.get('provisioned_bandwidth_in_mbps', None)
+        self.provisioned_bandwidth_in_mbps = None
         self.session_address_provider = kwargs.get('session_address_provider', None)
         self.use_for_peering_service = kwargs.get('use_for_peering_service', None)
         self.peering_db_facility_id = kwargs.get('peering_db_facility_id', None)
         self.connection_state = None
         self.bgp_session = kwargs.get('bgp_session', None)
         self.connection_identifier = kwargs.get('connection_identifier', None)
+        self.error_message = None
 
 
 class DirectPeeringFacility(Model):
@@ -291,17 +298,22 @@ class ExchangeConnection(Model):
     :param connection_identifier: The unique identifier (GUID) for the
      connection.
     :type connection_identifier: str
+    :ivar error_message: The error message related to the connection state, if
+     any.
+    :vartype error_message: str
     """
 
     _validation = {
         'connection_state': {'readonly': True},
+        'error_message': {'readonly': True},
     }
 
     _attribute_map = {
         'peering_db_facility_id': {'key': 'peeringDBFacilityId', 'type': 'int'},
         'connection_state': {'key': 'connectionState', 'type': 'str'},
         'bgp_session': {'key': 'bgpSession', 'type': 'BgpSession'},
         'connection_identifier': {'key': 'connectionIdentifier', 'type': 'str'},
+        'error_message': {'key': 'errorMessage', 'type': 'str'},
     }
 
     def __init__(self, **kwargs):
@@ -310,6 +322,7 @@ def __init__(self, **kwargs):
         self.connection_state = None
         self.bgp_session = kwargs.get('bgp_session', None)
         self.connection_identifier = kwargs.get('connection_identifier', None)
+        self.error_message = None
 
 
 class ExchangePeeringFacility(Model):
@@ -487,12 +500,15 @@ class PeerAsn(Resource):
     :param validation_state: The validation state of the ASN associated with
      the peer. Possible values include: 'None', 'Pending', 'Approved', 'Failed'
     :type validation_state: str or ~azure.mgmt.peering.models.ValidationState
+    :ivar error_message: The error message for the validation state
+    :vartype error_message: str
     """
 
     _validation = {
         'name': {'readonly': True},
         'id': {'readonly': True},
         'type': {'readonly': True},
+        'error_message': {'readonly': True},
     }
 
     _attribute_map = {
@@ -503,6 +519,7 @@ class PeerAsn(Resource):
         'peer_contact_info': {'key': 'properties.peerContactInfo', 'type': 'ContactInfo'},
         'peer_name': {'key': 'properties.peerName', 'type': 'str'},
         'validation_state': {'key': 'properties.validationState', 'type': 'str'},
+        'error_message': {'key': 'properties.errorMessage', 'type': 'str'},
     }
 
     def __init__(self, **kwargs):
@@ -511,6 +528,7 @@ def __init__(self, **kwargs):
         self.peer_contact_info = kwargs.get('peer_contact_info', None)
         self.peer_name = kwargs.get('peer_name', None)
         self.validation_state = kwargs.get('validation_state', None)
+        self.error_message = None
 
 
 class Peering(Resource):
@@ -709,12 +727,15 @@ def __init__(self, **kwargs):
 class PeeringPropertiesDirect(Model):
     """The properties that define a direct peering.
 
+    Variables are only populated by the server, and will be ignored when
+    sending a request.
+
     :param connections: The set of connections that constitute a direct
      peering.
     :type connections: list[~azure.mgmt.peering.models.DirectConnection]
-    :param use_for_peering_service: The flag that indicates whether or not the
+    :ivar use_for_peering_service: The flag that indicates whether or not the
      peering is used for peering service.
-    :type use_for_peering_service: bool
+    :vartype use_for_peering_service: bool
     :param peer_asn: The reference of the peer ASN.
     :type peer_asn: ~azure.mgmt.peering.models.SubResource
     :param direct_peering_type: The type of direct peering. Possible values
@@ -723,6 +744,10 @@ class PeeringPropertiesDirect(Model):
      ~azure.mgmt.peering.models.DirectPeeringType
     """
 
+    _validation = {
+        'use_for_peering_service': {'readonly': True},
+    }
+
     _attribute_map = {
         'connections': {'key': 'connections', 'type': '[DirectConnection]'},
         'use_for_peering_service': {'key': 'useForPeeringService', 'type': 'bool'},
@@ -733,7 +758,7 @@ class PeeringPropertiesDirect(Model):
     def __init__(self, **kwargs):
         super(PeeringPropertiesDirect, self).__init__(**kwargs)
         self.connections = kwargs.get('connections', None)
-        self.use_for_peering_service = kwargs.get('use_for_peering_service', None)
+        self.use_for_peering_service = None
         self.peer_asn = kwargs.get('peer_asn', None)
         self.direct_peering_type = kwargs.get('direct_peering_type', None)
 
@@ -870,16 +895,21 @@ class PeeringServicePrefix(Resource):
     :vartype id: str
     :ivar type: The type of the resource.
     :vartype type: str
-    :param prefix: Valid route prefix
+    :param prefix: The prefix from which your traffic originates.
     :type prefix: str
-    :param prefix_validation_state: The prefix validation state. Possible
+    :ivar prefix_validation_state: The prefix validation state. Possible
      values include: 'None', 'Invalid', 'Verified', 'Failed', 'Pending',
-     'Unknown'
-    :type prefix_validation_state: str or
+     'Warning', 'Unknown'
+    :vartype prefix_validation_state: str or
      ~azure.mgmt.peering.models.PrefixValidationState
-    :param learned_type: The prefix learned type. Possible values include:
-     'None', 'ViaPartner', 'ViaSession'
-    :type learned_type: str or ~azure.mgmt.peering.models.LearnedType
+    :ivar learned_type: The prefix learned type. Possible values include:
+     'None', 'ViaServiceProvider', 'ViaSession'
+    :vartype learned_type: str or ~azure.mgmt.peering.models.LearnedType
+    :ivar error_message: The error message for validation state
+    :vartype error_message: str
+    :ivar events: The list of events for peering service prefix
+    :vartype events:
+     list[~azure.mgmt.peering.models.PeeringServicePrefixEvent]
     :ivar provisioning_state: The provisioning state of the resource. Possible
      values include: 'Succeeded', 'Updating', 'Deleting', 'Failed'
     :vartype provisioning_state: str or
@@ -890,6 +920,10 @@ class PeeringServicePrefix(Resource):
         'name': {'readonly': True},
         'id': {'readonly': True},
         'type': {'readonly': True},
+        'prefix_validation_state': {'readonly': True},
+        'learned_type': {'readonly': True},
+        'error_message': {'readonly': True},
+        'events': {'readonly': True},
         'provisioning_state': {'readonly': True},
     }
 
@@ -900,17 +934,66 @@ class PeeringServicePrefix(Resource):
         'prefix': {'key': 'properties.prefix', 'type': 'str'},
         'prefix_validation_state': {'key': 'properties.prefixValidationState', 'type': 'str'},
         'learned_type': {'key': 'properties.learnedType', 'type': 'str'},
+        'error_message': {'key': 'properties.errorMessage', 'type': 'str'},
+        'events': {'key': 'properties.events', 'type': '[PeeringServicePrefixEvent]'},
         'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
     }
 
     def __init__(self, **kwargs):
         super(PeeringServicePrefix, self).__init__(**kwargs)
         self.prefix = kwargs.get('prefix', None)
-        self.prefix_validation_state = kwargs.get('prefix_validation_state', None)
-        self.learned_type = kwargs.get('learned_type', None)
+        self.prefix_validation_state = None
+        self.learned_type = None
+        self.error_message = None
+        self.events = None
         self.provisioning_state = None
 
 
+class PeeringServicePrefixEvent(Model):
+    """The details of the event associated with a prefix.
+
+    Variables are only populated by the server, and will be ignored when
+    sending a request.
+
+    :ivar event_timestamp: The timestamp of the event associated with a
+     prefix.
+    :vartype event_timestamp: datetime
+    :ivar event_type: The type of the event associated with a prefix.
+    :vartype event_type: str
+    :ivar event_summary: The summary of the event associated with a prefix.
+    :vartype event_summary: str
+    :ivar event_level: The level of the event associated with a prefix.
+    :vartype event_level: str
+    :ivar event_description: The description of the event associated with a
+     prefix.
+    :vartype event_description: str
+    """
+
+    _validation = {
+        'event_timestamp': {'readonly': True},
+        'event_type': {'readonly': True},
+        'event_summary': {'readonly': True},
+        'event_level': {'readonly': True},
+        'event_description': {'readonly': True},
+    }
+
+    _attribute_map = {
+        'event_timestamp': {'key': 'eventTimestamp', 'type': 'iso-8601'},
+        'event_type': {'key': 'eventType', 'type': 'str'},
+        'event_summary': {'key': 'eventSummary', 'type': 'str'},
+        'event_level': {'key': 'eventLevel', 'type': 'str'},
+        'event_description': {'key': 'eventDescription', 'type': 'str'},
+    }
+
+    def __init__(self, **kwargs):
+        super(PeeringServicePrefixEvent, self).__init__(**kwargs)
+        self.event_timestamp = None
+        self.event_type = None
+        self.event_summary = None
+        self.event_level = None
+        self.event_description = None
+
+
 class PeeringServiceProvider(Resource):
     """PeeringService provider.