def serialize_obj(self, obj, class_name):
'''
Return a JSON representation of an Azure object.
:param obj: Azure object
:param class_name: Name of the object's class
:return: serialized result
'''
serializer = Serializer()
return serializer.body(obj, class_name)
def test_list_not_wrapped_complex_types(self):
"""Test XML list and wrap, items is ref and there is no itemsName.
"""
basic_xml = ET.fromstring("""<?xml version="1.0"?>
<AppleBarrel>
<Apple name="granny"/>
<Apple name="fuji"/>
</AppleBarrel>""")
class AppleBarrel(Model):
_attribute_map = {
# Name is ignored if "wrapped" is False
'good_apples': {
'key': 'GoodApples',
'type': '[Apple]',
'xml': {
'name': 'GoodApples'
}
},
}
_xml_map = {'name': 'AppleBarrel'}
class Apple(Model):
_attribute_map = {
'name': {
'key': 'name',
'type': 'str',
'xml': {
'name': 'name',
'attr': True
}
},
}
_xml_map = {'name': 'Apple'}
mymodel = AppleBarrel(
good_apples=[Apple(
name='granny'), Apple(name='fuji')])
s = Serializer({"AppleBarrel": AppleBarrel, "Apple": Apple})
rawxml = s.body(mymodel, 'AppleBarrel')
assert_xml_equals(rawxml, basic_xml)
def serialize_obj(self, obj, class_name, enum_modules=[]):
'''
Return a JSON representation of an Azure object.
:param obj: Azure object
:param class_name: Name of the object's class
:param enum_modules: List of module names to build enum dependencies from.
:return: serialized result
'''
dependencies = dict()
if enum_modules:
for module_name in enum_modules:
mod = importlib.import_module(module_name)
for mod_class_name, mod_class_obj in inspect.getmembers(mod, predicate=inspect.isclass):
dependencies[mod_class_name] = mod_class_obj
self.log("dependencies: ")
self.log(str(dependencies))
serializer = Serializer(classes=dependencies)
return serializer.body(obj, class_name)
def serialize_obj(self, obj, class_name, enum_modules=[]):
'''
Return a JSON representation of an Azure object.
:param obj: Azure object
:param class_name: Name of the object's class
:param enum_modules: List of module names to build enum dependencies from.
:return: serialized result
'''
dependencies = dict()
if enum_modules:
for module_name in enum_modules:
mod = importlib.import_module(module_name)
for mod_class_name, mod_class_obj in inspect.getmembers(mod, predicate=inspect.isclass):
dependencies[mod_class_name] = mod_class_obj
self.log("dependencies: ");
self.log(str(dependencies))
serializer = Serializer(classes=dependencies)
return serializer.body(obj, class_name)
def serializer_helper(object_to_serialize: Model) -> dict:
if object_to_serialize is None:
return None
dependencies = [
schema_cls for key, schema_cls in getmembers(schema)
if isinstance(schema_cls, type) and issubclass(schema_cls, (Model,
Enum))
]
dependencies += [
schema_cls for key, schema_cls in getmembers(teams_schema)
if isinstance(schema_cls, type) and issubclass(schema_cls, (Model,
Enum))
]
dependencies_dict = {
dependency.__name__: dependency
for dependency in dependencies
}
serializer = Serializer(dependencies_dict)
# pylint: disable=protected-access
return serializer._serialize(object_to_serialize)
def test_list_wrapped_items_name_complex_types(self):
"""Test XML list and wrap, items is ref and there is itemsName.
"""
basic_xml = ET.fromstring("""<?xml version="1.0"?>
<AppleBarrel>
<GoodApples>
<Apple name="granny"/>
<Apple name="fuji"/>
</GoodApples>
</AppleBarrel>""")
class AppleBarrel(Model):
_attribute_map = {
# Pomme should be ignored, since it's invalid to define itemsName for a $ref type
'good_apples': {'key': 'GoodApples', 'type': '[Apple]', 'xml': {'name': 'GoodApples', 'wrapped': True, 'itemsName': 'Pomme'}},
}
_xml_map = {
'name': 'AppleBarrel'
}
class Apple(Model):
_attribute_map = {
'name': {'key': 'name', 'type': 'str', 'xml':{'name': 'name', 'attr': True}},
}
_xml_map = {
'name': 'Apple'
}
mymodel = AppleBarrel(
good_apples=[
Apple(name='granny'),
Apple(name='fuji')
]
)
s = Serializer({"AppleBarrel": AppleBarrel, "Apple": Apple})
rawxml = s.body(mymodel, 'AppleBarrel')
assert_xml_equals(rawxml, basic_xml)
def __init__(self):
self.config = KeyVaultSampleConfig()
self.credentials = None
self.keyvault_data_client = None
self.keyvault_mgmt_client = None
self.resource_mgmt_client = None
self._setup_complete = False
self.samples = {(name, m)
for name, m in inspect.getmembers(self)
if getattr(m, 'kv_sample', False)}
models = {}
models.update({
k: v
for k, v in azure.keyvault.models.__dict__.items()
if isinstance(v, type)
})
models.update({
k: v
for k, v in azure.mgmt.keyvault.models.__dict__.items()
if isinstance(v, type)
})
self._serializer = Serializer(models)
def test_basic_namespace(self):
"""Test an ultra basic XML."""
basic_xml = ET.fromstring("""<?xml version="1.0"?>
<Data xmlns:fictional="http://characters.example.com">
<fictional:Age>37</fictional:Age>
</Data>""")
class XmlModel(Model):
_attribute_map = {
'age': {'key': 'age', 'type': 'int', 'xml':{'name': 'Age', 'prefix':'fictional','ns':'http://characters.example.com'}},
}
_xml_map = {
'name': 'Data'
}
mymodel = XmlModel(
age=37,
)
s = Serializer({"XmlModel": XmlModel})
rawxml = s.body(mymodel, 'XmlModel')
assert_xml_equals(rawxml, basic_xml)
def test_basic_unicode(self):
"""Test a XML with unicode."""
basic_xml = ET.fromstring(u"""<?xml version="1.0" encoding="utf-8"?>
<Data language="français"/>""".encode("utf-8"))
class XmlModel(Model):
_attribute_map = {
'language': {
'key': 'language',
'type': 'str',
'xml': {
'name': 'language',
'attr': True
}
},
}
_xml_map = {'name': 'Data'}
mymodel = XmlModel(language=u"français")
s = Serializer({"XmlModel": XmlModel})
rawxml = s.body(mymodel, 'XmlModel')
assert_xml_equals(rawxml, basic_xml)
def test_two_complex_same_type(self):
"""Two different attribute are same type
"""
basic_xml = ET.fromstring("""<?xml version="1.0"?>
<AppleBarrel>
<EuropeanApple name="granny"/>
<USAApple name="fuji"/>
</AppleBarrel>""")
class AppleBarrel(Model):
_attribute_map = {
'eu_apple': {'key': 'EuropeanApple', 'type': 'Apple', 'xml': {'name': 'EuropeanApple'}},
'us_apple': {'key': 'USAApple', 'type': 'Apple', 'xml': {'name': 'USAApple'}},
}
_xml_map = {
'name': 'AppleBarrel'
}
class Apple(Model):
_attribute_map = {
'name': {'key': 'name', 'type': 'str', 'xml':{'name': 'name', 'attr': True}},
}
_xml_map = {
'name': 'Apple'
}
mymodel = AppleBarrel(
eu_apple=Apple(name='granny'),
us_apple=Apple(name='fuji'),
)
s = Serializer({"AppleBarrel": AppleBarrel, "Apple": Apple})
rawxml = s.body(mymodel, 'AppleBarrel')
assert_xml_equals(rawxml, basic_xml)
class KeyVaultSampleBase(object):
"""Base class for Key Vault samples, provides common functionality needed across Key Vault sample code
:ivar config: Azure subscription id for the user intending to run the sample
:vartype config: :class: `KeyVaultSampleConfig`q
:ivar credentials: Azure Active Directory credentials used to authenticate with Azure services
:vartype credentials: :class: `ServicePrincipalCredentials
<msrestazure.azure_active_directory.ServicePrincipalCredentials>`
:ivar keyvault_data_client: Key Vault data client used for interacting with key vaults
:vartype keyvault_data_client: :class: `KeyVaultClient <azure.keyvault.KeyVaultClient>`
:ivar keyvault_mgmt_client: Key Vault management client used for creating and managing key vaults
:vartype keyvault_mgmt_client: :class: `KeyVaultManagementClient <azure.mgmt.keyvault.KeyVaultManagementClient>`
:ivar resource_mgmt_client: Azure resource management client used for managing azure resources, access, and groups
:vartype resource_mgmt_client: :class: `ResourceManagementClient <azure.mgmt.resource.ResourceManagementClient>`
"""
def __init__(self):
self.config = KeyVaultSampleConfig()
self.credentials = None
self.keyvault_data_client = None
self.keyvault_mgmt_client = None
self.resource_mgmt_client = None
self._setup_complete = False
self.samples = {(name, m)
for name, m in inspect.getmembers(self)
if getattr(m, 'kv_sample', False)}
models = {}
models.update({
k: v
for k, v in azure.keyvault.models.__dict__.items()
if isinstance(v, type)
})
models.update({
k: v
for k, v in azure.mgmt.keyvault.models.__dict__.items()
if isinstance(v, type)
})
self._serializer = Serializer(models)
def setup_sample(self):
"""
Provides common setup for Key Vault samples, such as creating rest clients, creating a sample resource group
if needed, and ensuring proper access for the service principal.
:return: None
"""
if not self._setup_complete:
self.mgmt_creds = ServicePrincipalCredentials(
client_id=self.config.client_id,
secret=self.config.client_secret,
tenant=self.config.tenant_id)
self.data_creds = ServicePrincipalCredentials(
client_id=self.config.client_id,
secret=self.config.client_secret,
tenant=self.config.tenant_id)
self.resource_mgmt_client = ResourceManagementClient(
self.mgmt_creds, self.config.subscription_id)
# ensure the service principle has key vault as a valid provider
self.resource_mgmt_client.providers.register('Microsoft.KeyVault')
# ensure the intended resource group exists
self.resource_mgmt_client.resource_groups.create_or_update(
self.config.group_name, {'location': self.config.location})
self.keyvault_mgmt_client = KeyVaultManagementClient(
self.mgmt_creds, self.config.subscription_id)
self.keyvault_data_client = KeyVaultClient(self.data_creds)
self._setup_complete = True
def create_vault(self):
"""
Creates a new key vault with a unique name, granting full permissions to the current credentials
:return: a newly created key vault
:rtype: :class:`Vault <azure.keyvault.generated.models.Vault>`
"""
vault_name = get_name('vault')
# setup vault permissions for the access policy for the sample service principle
permissions = Permissions()
permissions.keys = KEY_PERMISSIONS_ALL
permissions.secrets = SECRET_PERMISSIONS_ALL
permissions.certificates = CERTIFICATE_PERMISSIONS_ALL
policy = AccessPolicyEntry(self.config.tenant_id,
self.config.client_oid, permissions)
properties = VaultProperties(self.config.tenant_id,
Sku(name='standard'),
access_policies=[policy])
parameters = VaultCreateOrUpdateParameters(self.config.location,
properties)
parameters.properties.enabled_for_deployment = True
parameters.properties.enabled_for_disk_encryption = True
parameters.properties.enabled_for_template_deployment = True
print('creating vault {}'.format(vault_name))
vault = self.keyvault_mgmt_client.vaults.create_or_update(
self.config.group_name, vault_name, parameters)
# wait for vault DNS entry to be created
# see issue: https://github.com/Azure/azure-sdk-for-python/issues/1172
self._poll_for_vault_connection(vault.properties.vault_uri)
print('created vault {} {}'.format(vault_name,
vault.properties.vault_uri))
return vault
def _poll_for_vault_connection(self,
vault_uri,
retry_wait=10,
max_retries=4):
"""
polls the data client 'get_secrets' method until a 200 response is received indicating the the vault
is available for data plane requests
"""
last_error = None
for x in range(max_retries - 1):
try:
# sleep first to avoid improper DNS caching
time.sleep(retry_wait)
self.keyvault_data_client.get_secrets(vault_uri)
return
except ClientRequestError as e:
print('vault connection not available')
last_error = e
raise last_error
def _serialize(self, obj):
if isinstance(obj, Paged):
serialized = [self._serialize(i) for i in list(obj)]
else:
serialized = self._serializer.body(obj, type(obj).__name__)
return json.dumps(serialized, indent=4, separators=(',', ': '))