ansible-collections/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2025-07-22 12:50:22 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

compute models

Browse source
This commit is contained in:
Zhijun Zhao 2017-12-28 16:58:56 +08:00 • committed by Matt Davis
commit 1fecb6f923
6 changed files with 83 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

7
lib/ansible/modules/cloud/azure/azure_rm_availabilityset.py
View file

@ -112,9 +112,6 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try:
from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import (
AvailabilitySet, Sku
)
except ImportError:
# This is handled in azure_rm_common
pass
@ -260,10 +257,10 @@ class AzureRMAvailabilitySet(AzureRMModuleBase):
'''
self.log("Creating availabilityset {0}".format(self.name))
try:
params_sku = Sku(
params_sku = self.compute_models.Sku(
name=self.sku
)
params = AvailabilitySet(
params = self.compute_models.AvailabilitySet(
location=self.location,
tags=self.tags,
platform_update_domain_count=self.platform_update_domain_count,

21
lib/ansible/modules/cloud/azure/azure_rm_image.py
View file

@ -100,7 +100,6 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase, format_resou
try:
from msrestazure.tools import parse_resource_id
from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import SubResource, OperatingSystemStateTypes, ImageStorageProfile, Image, ImageOSDisk, ImageDataDisk
except ImportError:
# This is handled in azure_rm_common
pass
@ -177,14 +176,14 @@ class AzureRMImage(AzureRMModuleBase):
if vm:
if self.data_disk_sources:
self.fail('data_disk_sources is not allowed when capturing image from vm')
image_instance = Image(self.location, source_virtual_machine=SubResource(vm.id))
image_instance = self.compute_models.Image(self.location, source_virtual_machine=self.compute_models.SubResource(vm.id))
else:
if not self.os_type:
self.fail('os_type is required to create the image')
os_disk = self.create_os_disk()
data_disks = self.create_data_disks()
storage_profile = ImageStorageProfile(os_disk=os_disk, data_disks=data_disks)
image_instance = Image(self.location, storage_profile=storage_profile, tags=self.tags)
storage_profile = self.compute_models.ImageStorageProfile(os_disk=os_disk, data_disks=data_disks)
image_instance = self.compute_models.Image(self.location, storage_profile=storage_profile, tags=self.tags)
# finally make the change if not check mode
if not self.check_mode and image_instance:
@ -234,10 +233,10 @@ class AzureRMImage(AzureRMModuleBase):
def create_os_disk(self):
blob_uri, disk, snapshot = self.resolve_storage_source(self.source)
snapshot_resource = SubResource(snapshot) if snapshot else None
managed_disk = SubResource(disk) if disk else None
return ImageOSDisk(os_type=self.os_type,
os_state=OperatingSystemStateTypes.generalized,
snapshot_resource = self.compute_models.SubResource(snapshot) if snapshot else None
managed_disk = self.compute_models.SubResource(disk) if disk else None
return self.compute_models.ImageOSDisk(os_type=self.os_type,
os_state=self.compute_models.OperatingSystemStateTypes.generalized,
snapshot=snapshot_resource,
managed_disk=managed_disk,
blob_uri=blob_uri)
@ -245,9 +244,9 @@ class AzureRMImage(AzureRMModuleBase):
def create_data_disk(self, lun, source):
blob_uri, disk, snapshot = self.resolve_storage_source(source)
if blob_uri or disk or snapshot:
snapshot_resource = SubResource(snapshot) if snapshot else None
managed_disk = SubResource(disk) if disk else None
return ImageDataDisk(lun,
snapshot_resource = self.compute_models.SubResource(snapshot) if snapshot else None
managed_disk = self.compute_models.SubResource(disk) if disk else None
return self.compute_models.ImageDataDisk(lun,
blob_uri=blob_uri,
snapshot=snapshot_resource,
managed_disk=managed_disk)

13
lib/ansible/modules/cloud/azure/azure_rm_managed_disk.py
View file

@ -141,7 +141,6 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try:
from msrestazure.tools import parse_resource_id
from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import DiskCreateOption, DiskCreateOptionTypes, ManagedDiskParameters, DiskSku, DataDisk
except ImportError:
# This is handled in azure_rm_common
pass
@ -289,8 +288,8 @@ class AzureRMManagedDisk(AzureRMModuleBase):
lun = max(luns) + 1 if luns else 0
# prepare the data disk
params = ManagedDiskParameters(id=disk.get('id'), storage_account_type=disk.get('storage_account_type'))
data_disk = DataDisk(lun, DiskCreateOptionTypes.attach, managed_disk=params)
params = self.compute_models.ManagedDiskParameters(id=disk.get('id'), storage_account_type=disk.get('storage_account_type'))
data_disk = self.compute_models.DataDisk(lun, self.compute_models.DiskCreateOptionTypes.attach, managed_disk=params)
vm.storage_profile.data_disks.append(data_disk)
self._update_vm(vm_name, vm)
@ -321,16 +320,16 @@ class AzureRMManagedDisk(AzureRMModuleBase):
disk_params['location'] = self.location
disk_params['tags'] = self.tags
if self.storage_account_type:
storage_account_type = DiskSku(self.storage_account_type)
storage_account_type = self.compute_models.DiskSku(self.storage_account_type)
disk_params['sku'] = storage_account_type
disk_params['disk_size_gb'] = self.disk_size_gb
# TODO: Add support for EncryptionSettings
creation_data['create_option'] = DiskCreateOption.empty
creation_data['create_option'] = self.compute_models.DiskCreateOption.empty
if self.create_option == 'import':
creation_data['create_option'] = DiskCreateOption.import_enum
creation_data['create_option'] = self.compute_models.DiskCreateOption.import_enum
creation_data['source_uri'] = self.source_uri
elif self.create_option == 'copy':
creation_data['create_option'] = DiskCreateOption.copy
creation_data['create_option'] = self.compute_models.DiskCreateOption.copy
creation_data['source_resource_id'] = self.source_resource_uri
disk_params['creation_data'] = creation_data
return disk_params

81
lib/ansible/modules/cloud/azure/azure_rm_virtualmachine.py
View file

@ -597,13 +597,6 @@ import re
try:
from msrestazure.azure_exceptions import CloudError
from msrestazure.tools import parse_resource_id
from azure.mgmt.compute.models import NetworkInterfaceReference, \
VirtualMachine, HardwareProfile, \
StorageProfile, OSProfile, OSDisk, DataDisk, \
VirtualHardDisk, ManagedDiskParameters, \
ImageReference, NetworkProfile, LinuxConfiguration, \
SshConfiguration, SshPublicKey, VirtualMachineSizeTypes, \
DiskCreateOptionTypes, Plan, SubResource
except ImportError:
# This is handled in azure_rm_common
pass
@ -763,7 +756,7 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
self.image['version'] = marketplace_image.name
self.log("Using image version {0}".format(self.image['version']))
image_reference = ImageReference(
image_reference = self.network_models.ImageReference(
publisher=self.image['publisher'],
offer=self.image['offer'],
sku=self.image['sku'],
@ -905,7 +898,7 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
parsed_availability_set = parse_resource_id(self.availability_set)
availability_set = self.get_availability_set(parsed_availability_set.get('resource_group', self.resource_group),
parsed_availability_set.get('name'))
availability_set_resource = SubResource(availability_set.id)
availability_set_resource = self.network_models.SubResource(availability_set.id)
# Get defaults
if not self.network_interface_names:
@ -929,45 +922,45 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
if not self.short_hostname:
self.short_hostname = self.name
nics = [NetworkInterfaceReference(id=id) for id in network_interfaces]
nics = [self.network_models.NetworkInterfaceReference(id=id) for id in network_interfaces]
# os disk
if self.managed_disk_type:
vhd = None
managed_disk = ManagedDiskParameters(storage_account_type=self.managed_disk_type)
managed_disk = self.network_models.ManagedDiskParameters(storage_account_type=self.managed_disk_type)
elif custom_image:
vhd = None
managed_disk = None
else:
vhd = VirtualHardDisk(uri=requested_vhd_uri)
vhd = self.network_models.VirtualHardDisk(uri=requested_vhd_uri)
managed_disk = None
plan = None
if self.plan:
plan = Plan(name=self.plan.get('name'), product=self.plan.get('product'), publisher=self.plan.get('publisher'),
plan = self.network_models.Plan(name=self.plan.get('name'), product=self.plan.get('product'), publisher=self.plan.get('publisher'),
promotion_code=self.plan.get('promotion_code'))
vm_resource = VirtualMachine(
vm_resource = self.network_models.VirtualMachine(
self.location,
tags=self.tags,
os_profile=OSProfile(
os_profile=self.network_models.OSProfile(
admin_username=self.admin_username,
computer_name=self.short_hostname,
),
hardware_profile=HardwareProfile(
hardware_profile=self.network_models.HardwareProfile(
vm_size=self.vm_size
),
storage_profile=StorageProfile(
os_disk=OSDisk(
storage_profile=self.network_models.StorageProfile(
os_disk=self.network_models.OSDisk(
name=self.storage_blob_name,
vhd=vhd,
managed_disk=managed_disk,
create_option=DiskCreateOptionTypes.from_image,
create_option=self.network_models.DiskCreateOptionTypes.from_image,
caching=self.os_disk_caching,
),
image_reference=image_reference,
),
network_profile=NetworkProfile(
network_profile=self.network_models.NetworkProfile(
network_interfaces=nics
),
availability_set=availability_set_resource,
@ -978,13 +971,13 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
vm_resource.os_profile.admin_password = self.admin_password
if self.os_type == 'Linux':
vm_resource.os_profile.linux_configuration = LinuxConfiguration(
vm_resource.os_profile.linux_configuration = self.network_models.LinuxConfiguration(
disable_password_authentication=disable_ssh_password
)
if self.ssh_public_keys:
ssh_config = SshConfiguration()
ssh_config = self.network_models.SshConfiguration()
ssh_config.public_keys = \
[SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys]
[self.network_models.SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys]
vm_resource.os_profile.linux_configuration.ssh = ssh_config
# data disk
@ -1022,10 +1015,10 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
if not data_disk.get('managed_disk_type'):
data_disk_managed_disk = None
disk_name = data_disk['storage_blob_name']
data_disk_vhd = VirtualHardDisk(uri=data_disk_requested_vhd_uri)
data_disk_vhd = self.network_models.VirtualHardDisk(uri=data_disk_requested_vhd_uri)
else:
data_disk_vhd = None
data_disk_managed_disk = ManagedDiskParameters(storage_account_type=data_disk['managed_disk_type'])
data_disk_managed_disk = self.network_models.ManagedDiskParameters(storage_account_type=data_disk['managed_disk_type'])
disk_name = self.name + "-datadisk-" + str(count)
count += 1
@ -1033,12 +1026,12 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
'caching', 'ReadOnly'
)
data_disks.append(DataDisk(
data_disks.append(self.network_models.DataDisk(
lun=data_disk['lun'],
name=disk_name,
vhd=data_disk_vhd,
caching=data_disk['caching'],
create_option=DiskCreateOptionTypes.empty,
create_option=self.network_models.DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'],
managed_disk=data_disk_managed_disk,
))
@ -1054,37 +1047,37 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
self.log("Update virtual machine {0}".format(self.name))
self.results['actions'].append('Updated VM {0}'.format(self.name))
nics = [NetworkInterfaceReference(id=interface['id'])
nics = [self.network_models.NetworkInterfaceReference(id=interface['id'])
for interface in vm_dict['properties']['networkProfile']['networkInterfaces']]
# os disk
if not vm_dict['properties']['storageProfile']['osDisk'].get('managedDisk'):
managed_disk = None
vhd = VirtualHardDisk(uri=vm_dict['properties']['storageProfile']['osDisk']['vhd']['uri'])
vhd = self.network_models.VirtualHardDisk(uri=vm_dict['properties']['storageProfile']['osDisk']['vhd']['uri'])
else:
vhd = None
managed_disk = ManagedDiskParameters(
managed_disk = self.network_models.ManagedDiskParameters(
storage_account_type=vm_dict['properties']['storageProfile']['osDisk']['managedDisk']['storageAccountType']
)
availability_set_resource = None
try:
availability_set_resource = SubResource(vm_dict['properties']['availabilitySet']['id'])
availability_set_resource = self.network_models.SubResource(vm_dict['properties']['availabilitySet']['id'])
except Exception:
# pass if the availability set is not set
pass
vm_resource = VirtualMachine(
vm_resource = self.network_models.VirtualMachine(
vm_dict['location'],
os_profile=OSProfile(
os_profile=self.network_models.OSProfile(
admin_username=vm_dict['properties']['osProfile']['adminUsername'],
computer_name=vm_dict['properties']['osProfile']['computerName']
),
hardware_profile=HardwareProfile(
hardware_profile=self.network_models.HardwareProfile(
vm_size=vm_dict['properties']['hardwareProfile']['vmSize']
),
storage_profile=StorageProfile(
os_disk=OSDisk(
storage_profile=self.network_models.StorageProfile(
os_disk=self.network_models.OSDisk(
name=vm_dict['properties']['storageProfile']['osDisk']['name'],
vhd=vhd,
managed_disk=managed_disk,
@ -1092,7 +1085,7 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
os_type=vm_dict['properties']['storageProfile']['osDisk']['osType'],
caching=vm_dict['properties']['storageProfile']['osDisk']['caching'],
),
image_reference=ImageReference(
image_reference=self.network_models.ImageReference(
publisher=vm_dict['properties']['storageProfile']['imageReference']['publisher'],
offer=vm_dict['properties']['storageProfile']['imageReference']['offer'],
sku=vm_dict['properties']['storageProfile']['imageReference']['sku'],
@ -1100,7 +1093,7 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
),
),
availability_set=availability_set_resource,
network_profile=NetworkProfile(
network_profile=self.network_models.NetworkProfile(
network_interfaces=nics
),
)
@ -1116,16 +1109,16 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
linux_config = vm_dict['properties']['osProfile'].get('linuxConfiguration')
if linux_config:
ssh_config = linux_config.get('ssh', None)
vm_resource.os_profile.linux_configuration = LinuxConfiguration(
vm_resource.os_profile.linux_configuration = self.network_models.LinuxConfiguration(
disable_password_authentication=linux_config.get('disablePasswordAuthentication', False)
)
if ssh_config:
public_keys = ssh_config.get('publicKeys')
if public_keys:
vm_resource.os_profile.linux_configuration.ssh = SshConfiguration(public_keys=[])
vm_resource.os_profile.linux_configuration.ssh = self.network_models.SshConfiguration(public_keys=[])
for key in public_keys:
vm_resource.os_profile.linux_configuration.ssh.public_keys.append(
SshPublicKey(path=key['path'], key_data=key['keyData'])
self.network_models.SshPublicKey(path=key['path'], key_data=key['keyData'])
)
# data disk
@ -1135,13 +1128,13 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
for data_disk in vm_dict['properties']['storageProfile']['dataDisks']:
if data_disk.get('managedDisk'):
managed_disk_type = data_disk['managedDisk']['storageAccountType']
data_disk_managed_disk = ManagedDiskParameters(storage_account_type=managed_disk_type)
data_disk_managed_disk = self.network_models.ManagedDiskParameters(storage_account_type=managed_disk_type)
data_disk_vhd = None
else:
data_disk_vhd = data_disk['vhd']['uri']
data_disk_managed_disk = None
data_disks.append(DataDisk(
data_disks.append(self.network_models.DataDisk(
lun=int(data_disk['lun']),
name=data_disk.get('name'),
vhd=data_disk_vhd,
@ -1454,7 +1447,7 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
for vm_image in vm_images:
if vm_image.name == name:
self.log("Using custom image id {0}".format(vm_image.id))
return ImageReference(id=vm_image.id)
return self.network_models.ImageReference(id=vm_image.id)
self.fail("Error could not find image with name {0}".format(name))

5
lib/ansible/modules/cloud/azure/azure_rm_virtualmachine_extension.py
View file

@ -121,9 +121,6 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try:
from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import (
VirtualMachineExtension
)
except ImportError:
# This is handled in azure_rm_common
pass
@ -260,7 +257,7 @@ class AzureRMVMExtension(AzureRMModuleBase):
'''
self.log("Creating VM extension {0}".format(self.name))
try:
params = VirtualMachineExtension(
params = self.compute_models.VirtualMachineExtension(
location=self.location,
publisher=self.publisher,
virtual_machine_extension_type=self.virtual_machine_extension_type,

68
lib/ansible/modules/cloud/azure/azure_rm_virtualmachine_scaleset.py
View file

@ -339,20 +339,6 @@ import re
try:
from msrestazure.azure_exceptions import CloudError
from msrestazure.tools import parse_resource_id
from azure.mgmt.compute.models import VirtualMachineScaleSet, \
VirtualMachineScaleSetStorageProfile, \
VirtualMachineScaleSetOSProfile, \
VirtualMachineScaleSetOSDisk, VirtualMachineScaleSetDataDisk, \
VirtualMachineScaleSetManagedDiskParameters, \
VirtualMachineScaleSetNetworkProfile, LinuxConfiguration, \
SshConfiguration, SshPublicKey, VirtualMachineSizeTypes, \
DiskCreateOptionTypes, CachingTypes, \
VirtualMachineScaleSetVMProfile, VirtualMachineScaleSetIdentity, \
VirtualMachineScaleSetIPConfiguration, \
VirtualMachineScaleSetPublicIPAddressConfigurationDnsSettings, \
VirtualMachineScaleSetPublicIPAddressConfiguration, Sku, \
UpgradePolicy, VirtualMachineScaleSetNetworkConfiguration, \
ApiEntityReference, ImageReference, SubResource
except ImportError:
# This is handled in azure_rm_common
@ -481,7 +467,7 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
self.image['version'] = marketplace_image.name
self.log("Using image version {0}".format(self.image['version']))
image_reference = ImageReference(
image_reference = self.compute_models.ImageReference(
publisher=self.image['publisher'],
offer=self.image['offer'],
sku=self.image['sku'],
@ -583,10 +569,10 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
load_balancer_inbound_nat_pools = None
if self.load_balancer:
load_balancer = self.get_load_balancer(self.load_balancer)
load_balancer_backend_address_pools = ([SubResource(resource.id)
load_balancer_backend_address_pools = ([self.compute_models.SubResource(resource.id)
for resource in load_balancer.backend_address_pools]
if load_balancer.backend_address_pools else None)
load_balancer_inbound_nat_pools = ([SubResource(resource.id)
load_balancer_inbound_nat_pools = ([self.compute_models.SubResource(resource.id)
for resource in load_balancer.inbound_nat_pools]
if load_balancer.inbound_nat_pools else None)
@ -596,41 +582,41 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
if not image_reference:
self.fail("Parameter error: an image is required when creating a virtual machine.")
managed_disk = VirtualMachineScaleSetManagedDiskParameters(storage_account_type=self.managed_disk_type)
managed_disk = self.compute_models.VirtualMachineScaleSetManagedDiskParameters(storage_account_type=self.managed_disk_type)
vmss_resource = VirtualMachineScaleSet(
vmss_resource = self.compute_models.VirtualMachineScaleSet(
self.location,
tags=self.tags,
upgrade_policy=UpgradePolicy(
upgrade_policy=self.compute_models.UpgradePolicy(
mode=self.upgrade_policy
),
sku=Sku(
sku=self.compute_models.Sku(
name=self.vm_size,
capacity=self.capacity,
tier=self.tier,
),
virtual_machine_profile=VirtualMachineScaleSetVMProfile(
os_profile=VirtualMachineScaleSetOSProfile(
virtual_machine_profile=self.compute_models.VirtualMachineScaleSetVMProfile(
os_profile=self.compute_models.VirtualMachineScaleSetOSProfile(
admin_username=self.admin_username,
computer_name_prefix=self.short_hostname,
),
storage_profile=VirtualMachineScaleSetStorageProfile(
os_disk=VirtualMachineScaleSetOSDisk(
storage_profile=self.compute_models.VirtualMachineScaleSetStorageProfile(
os_disk=self.compute_models.VirtualMachineScaleSetOSDisk(
managed_disk=managed_disk,
create_option=DiskCreateOptionTypes.from_image,
create_option=self.compute_models.DiskCreateOptionTypes.from_image,
caching=self.os_disk_caching,
),
image_reference=image_reference,
),
network_profile=VirtualMachineScaleSetNetworkProfile(
network_profile=self.compute_models.VirtualMachineScaleSetNetworkProfile(
network_interface_configurations=[
VirtualMachineScaleSetNetworkConfiguration(
self.compute_models.VirtualMachineScaleSetNetworkConfiguration(
name=self.name,
primary=True,
ip_configurations=[
VirtualMachineScaleSetIPConfiguration(
self.compute_models.VirtualMachineScaleSetIPConfiguration(
name='default',
subnet=ApiEntityReference(
subnet=self.compute_models.ApiEntityReference(
id=subnet.id
),
primary=True,
@ -648,33 +634,33 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
vmss_resource.virtual_machine_profile.os_profile.admin_password = self.admin_password
if self.os_type == 'Linux':
vmss_resource.virtual_machine_profile.os_profile.linux_configuration = LinuxConfiguration(
vmss_resource.virtual_machine_profile.os_profile.linux_configuration = self.compute_models.LinuxConfiguration(
disable_password_authentication=disable_ssh_password
)
if self.ssh_public_keys:
ssh_config = SshConfiguration()
ssh_config = self.compute_models.SshConfiguration()
ssh_config.public_keys = \
[SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys]
[self.compute_models.SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys]
vmss_resource.virtual_machine_profile.os_profile.linux_configuration.ssh = ssh_config
if self.data_disks:
data_disks = []
for data_disk in self.data_disks:
data_disk_managed_disk = VirtualMachineScaleSetManagedDiskParameters(
data_disk_managed_disk = self.compute_models.VirtualMachineScaleSetManagedDiskParameters(
storage_account_type=data_disk['managed_disk_type']
)
data_disk['caching'] = data_disk.get(
'caching',
CachingTypes.read_only
self.compute_models.CachingTypes.read_only
)
data_disks.append(VirtualMachineScaleSetDataDisk(
data_disks.append(self.compute_models.VirtualMachineScaleSetDataDisk(
lun=data_disk['lun'],
caching=data_disk['caching'],
create_option=DiskCreateOptionTypes.empty,
create_option=self.compute_models.DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'],
managed_disk=data_disk_managed_disk,
))
@ -694,12 +680,12 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
data_disks = []
for data_disk in self.data_disks:
data_disks.append(VirtualMachineScaleSetDataDisk(
data_disks.append(self.compute_models.VirtualMachineScaleSetDataDisk(
lun=data_disk['lun'],
caching=data_disk['caching'],
create_option=DiskCreateOptionTypes.empty,
create_option=self.compute_models.DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'],
managed_disk=VirtualMachineScaleSetManagedDiskParameters(
managed_disk=self.compute_models.VirtualMachineScaleSetManagedDiskParameters(
storage_account_type=data_disk['managed_disk_type']
),
))
@ -822,7 +808,7 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
for vm_image in vm_images:
if vm_image.name == name:
self.log("Using custom image id {0}".format(vm_image.id))
return ImageReference(id=vm_image.id)
return self.compute_models.ImageReference(id=vm_image.id)
self.fail("Error could not find image with name {0}".format(name))