wbrawner/ansible
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

revert azure_rm model pinning (#35011)

Browse source 
* reverts #33897/#34682
* revisit in 2.4.4/2.5.0
This commit is contained in:
Matt Davis 2018-01-17 13:08:07 -08:00 committed by Toshio Kuratomi
parent 93297fd0d0
commit 949e2f06e5
15 changed files with 230 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
lib/ansible/module_utils/azure_rm_common.py
View file

@ -98,6 +98,8 @@ try:
from enum import Enum from enum import Enum
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from msrestazure import azure_cloud from msrestazure import azure_cloud
from azure.mgmt.network.models import PublicIPAddress, NetworkSecurityGroup, SecurityRule, NetworkInterface, \
NetworkInterfaceIPConfiguration, Subnet
from azure.common.credentials import ServicePrincipalCredentials, UserPassCredentials from azure.common.credentials import ServicePrincipalCredentials, UserPassCredentials
from azure.mgmt.network.version import VERSION as network_client_version from azure.mgmt.network.version import VERSION as network_client_version
from azure.mgmt.storage.version import VERSION as storage_client_version from azure.mgmt.storage.version import VERSION as storage_client_version
@ -603,7 +605,7 @@ class AzureRMModuleBase(object):
self.check_provisioning_state(pip) self.check_provisioning_state(pip)
return pip return pip
params = self.network_models.PublicIPAddress( params = PublicIPAddress(
location=location, location=location,
public_ip_allocation_method=allocation_method, public_ip_allocation_method=allocation_method,
) )
@ -643,7 +645,7 @@ class AzureRMModuleBase(object):
self.check_provisioning_state(group) self.check_provisioning_state(group)
return group return group
parameters = self.network_models.NetworkSecurityGroup() parameters = NetworkSecurityGroup()
parameters.location = location parameters.location = location
if not open_ports: if not open_ports:
@ -651,16 +653,16 @@ class AzureRMModuleBase(object):
if os_type == 'Linux': if os_type == 'Linux':
# add an inbound SSH rule # add an inbound SSH rule
parameters.security_rules = [ parameters.security_rules = [
self.network_models.SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow SSH Access', SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow SSH Access',
source_port_range='*', destination_port_range='22', priority=100, name='SSH') source_port_range='*', destination_port_range='22', priority=100, name='SSH')
] ]
parameters.location = location parameters.location = location
else: else:
# for windows add inbound RDP and WinRM rules # for windows add inbound RDP and WinRM rules
parameters.security_rules = [ parameters.security_rules = [
self.network_models.SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow RDP port 3389', SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow RDP port 3389',
source_port_range='*', destination_port_range='3389', priority=100, name='RDP01'), source_port_range='*', destination_port_range='3389', priority=100, name='RDP01'),
self.network_models.SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow WinRM HTTPS port 5986', SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow WinRM HTTPS port 5986',
source_port_range='*', destination_port_range='5986', priority=101, name='WinRM01'), source_port_range='*', destination_port_range='5986', priority=101, name='WinRM01'),
] ]
else: else:
@ -671,7 +673,7 @@ class AzureRMModuleBase(object):
priority += 1 priority += 1
rule_name = "Rule_{0}".format(priority) rule_name = "Rule_{0}".format(priority)
parameters.security_rules.append( parameters.security_rules.append(
self.network_models.SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', source_port_range='*', SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', source_port_range='*',
destination_port_range=str(port), priority=priority, name=rule_name) destination_port_range=str(port), priority=priority, name=rule_name)
) )
@ -718,11 +720,6 @@ class AzureRMModuleBase(object):
api_version='2017-10-01') api_version='2017-10-01')
return self._storage_client return self._storage_client
@property
def storage_models(self):
self.log('Getting storage models...')
return StorageManagementClient.models("2017-10-01")
@property @property
def network_client(self): def network_client(self):
self.log('Getting network client') self.log('Getting network client')
@ -732,11 +729,6 @@ class AzureRMModuleBase(object):
api_version='2017-06-01') api_version='2017-06-01')
return self._network_client return self._network_client
@property
def network_models(self):
self.log("Getting network models...")
return NetworkManagementClient.models("2017-06-01")
@property @property
def rm_client(self): def rm_client(self):
self.log('Getting resource manager client') self.log('Getting resource manager client')
@ -746,11 +738,6 @@ class AzureRMModuleBase(object):
api_version='2017-05-10') api_version='2017-05-10')
return self._resource_client return self._resource_client
@property
def rm_models(self):
self.log("Getting resource manager models")
return ResourceManagementClient.models("2017-05-10")
@property @property
def compute_client(self): def compute_client(self):
self.log('Getting compute client') self.log('Getting compute client')
@ -760,11 +747,6 @@ class AzureRMModuleBase(object):
api_version='2017-03-30') api_version='2017-03-30')
return self._compute_client return self._compute_client
@property
def compute_models(self):
self.log("Getting compute models")
return ComputeManagementClient.models("2017-03-30")
@property @property
def dns_client(self): def dns_client(self):
self.log('Getting dns client') self.log('Getting dns client')

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

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

16
lib/ansible/modules/cloud/azure/azure_rm_deployment.py
View file

@ -379,6 +379,12 @@ except ImportError as exc:
try: try:
from itertools import chain from itertools import chain
from azure.common.exceptions import CloudError from azure.common.exceptions import CloudError
from azure.mgmt.resource.resources.models import (DeploymentProperties,
ParametersLink,
TemplateLink,
Deployment,
ResourceGroup,
Dependency)
from azure.mgmt.resource.resources import ResourceManagementClient from azure.mgmt.resource.resources import ResourceManagementClient
from azure.mgmt.network import NetworkManagementClient from azure.mgmt.network import NetworkManagementClient
@ -476,21 +482,21 @@ class AzureRMDeploymentManager(AzureRMModuleBase):
:return: :return:
""" """
deploy_parameter = self.rm_models.DeploymentProperties(self.deployment_mode) deploy_parameter = DeploymentProperties(self.deployment_mode)
if not self.parameters_link: if not self.parameters_link:
deploy_parameter.parameters = self.parameters deploy_parameter.parameters = self.parameters
else: else:
deploy_parameter.parameters_link = self.rm_models.ParametersLink( deploy_parameter.parameters_link = ParametersLink(
uri=self.parameters_link uri=self.parameters_link
) )
if not self.template_link: if not self.template_link:
deploy_parameter.template = self.template deploy_parameter.template = self.template
else: else:
deploy_parameter.template_link = self.rm_models.TemplateLink( deploy_parameter.template_link = TemplateLink(
uri=self.template_link uri=self.template_link
) )
params = self.rm_models.ResourceGroup(location=self.location, tags=self.tags) params = ResourceGroup(location=self.location, tags=self.tags)
try: try:
self.rm_client.resource_groups.create_or_update(self.resource_group_name, params) self.rm_client.resource_groups.create_or_update(self.resource_group_name, params)
@ -621,7 +627,7 @@ class AzureRMDeploymentManager(AzureRMModuleBase):
for dep in dependencies: for dep in dependencies:
if dep.resource_name not in tree: if dep.resource_name not in tree:
tree[dep.resource_name] = dict(dep=dep, children=dict()) tree[dep.resource_name] = dict(dep=dep, children=dict())
if isinstance(dep, self.rm_models.Dependency) and dep.depends_on is not None and len(dep.depends_on) > 0: if isinstance(dep, Dependency) and dep.depends_on is not None and len(dep.depends_on) > 0:
self._build_hierarchy(dep.depends_on, tree[dep.resource_name]['children']) self._build_hierarchy(dep.depends_on, tree[dep.resource_name]['children'])
if 'top' in tree: if 'top' in tree:

32
lib/ansible/modules/cloud/azure/azure_rm_loadbalancer.py
View file

@ -184,6 +184,16 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import (
LoadBalancer,
FrontendIPConfiguration,
BackendAddressPool,
Probe,
LoadBalancingRule,
SubResource,
InboundNatPool,
Subnet
)
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -336,7 +346,7 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
if self.public_ip_address_name: if self.public_ip_address_name:
pip = self.get_public_ip_address(self.public_ip_address_name) pip = self.get_public_ip_address(self.public_ip_address_name)
load_balancer_props['frontend_ip_configurations'] = [ load_balancer_props['frontend_ip_configurations'] = [
self.network_models.FrontendIPConfiguration( FrontendIPConfiguration(
name=frontend_ip_config_name, name=frontend_ip_config_name,
public_ip_address=pip public_ip_address=pip
) )
@ -386,7 +396,7 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
load_balancer_name=self.name, load_balancer_name=self.name,
name=backend_address_pool_name name=backend_address_pool_name
) )
load_balancer_props['backend_address_pools'] = [self.network_models.BackendAddressPool(name=backend_address_pool_name)] load_balancer_props['backend_address_pools'] = [BackendAddressPool(name=backend_address_pool_name)]
probe_name = random_name('probe') probe_name = random_name('probe')
prb_id = probe_id( prb_id = probe_id(
@ -398,7 +408,7 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
if self.probe_protocol: if self.probe_protocol:
load_balancer_props['probes'] = [ load_balancer_props['probes'] = [
self.network_models.Probe( Probe(
name=probe_name, name=probe_name,
protocol=self.probe_protocol, protocol=self.probe_protocol,
port=self.probe_port, port=self.probe_port,
@ -411,11 +421,11 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
load_balancing_rule_name = random_name('lbr') load_balancing_rule_name = random_name('lbr')
if self.protocol: if self.protocol:
load_balancer_props['load_balancing_rules'] = [ load_balancer_props['load_balancing_rules'] = [
self.network_models.LoadBalancingRule( LoadBalancingRule(
name=load_balancing_rule_name, name=load_balancing_rule_name,
frontend_ip_configuration=self.network_models.SubResource(id=frontend_ip_config_id), frontend_ip_configuration=SubResource(id=frontend_ip_config_id),
backend_address_pool=self.network_models.SubResource(id=backend_addr_pool_id), backend_address_pool=SubResource(id=backend_addr_pool_id),
probe=self.network_models.SubResource(id=prb_id), probe=SubResource(id=prb_id),
protocol=self.protocol, protocol=self.protocol,
load_distribution=self.load_distribution, load_distribution=self.load_distribution,
frontend_port=self.frontend_port, frontend_port=self.frontend_port,
@ -428,9 +438,9 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
inbound_nat_pool_name = random_name('inp') inbound_nat_pool_name = random_name('inp')
if frontend_ip_config_id and self.natpool_protocol: if frontend_ip_config_id and self.natpool_protocol:
load_balancer_props['inbound_nat_pools'] = [ load_balancer_props['inbound_nat_pools'] = [
self.network_models.InboundNatPool( InboundNatPool(
name=inbound_nat_pool_name, name=inbound_nat_pool_name,
frontend_ip_configuration=self.network_models.Subnet(id=frontend_ip_config_id), frontend_ip_configuration=Subnet(id=frontend_ip_config_id),
protocol=self.natpool_protocol, protocol=self.natpool_protocol,
frontend_port_range_start=self.natpool_frontend_port_start, frontend_port_range_start=self.natpool_frontend_port_start,
frontend_port_range_end=self.natpool_frontend_port_end, frontend_port_range_end=self.natpool_frontend_port_end,
@ -441,7 +451,7 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
self.results['changed'] = changed self.results['changed'] = changed
self.results['state'] = ( self.results['state'] = (
results if results results if results
else load_balancer_to_dict(self.network_models.LoadBalancer(**load_balancer_props)) else load_balancer_to_dict(LoadBalancer(**load_balancer_props))
) )
if self.check_mode: if self.check_mode:
@ -451,7 +461,7 @@ class AzureRMLoadBalancer(AzureRMModuleBase):
self.network_client.load_balancers.create_or_update( self.network_client.load_balancers.create_or_update(
resource_group_name=self.resource_group, resource_group_name=self.resource_group,
load_balancer_name=self.name, load_balancer_name=self.name,
parameters=self.network_models.LoadBalancer(**load_balancer_props) parameters=LoadBalancer(**load_balancer_props)
).wait() ).wait()
except CloudError as err: except CloudError as err:
self.fail('Error creating load balancer {}'.format(err)) self.fail('Error creating load balancer {}'.format(err))

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

@ -130,6 +130,7 @@ import re
from ansible.module_utils.azure_rm_common import AzureRMModuleBase from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import DiskCreateOption
from azure.mgmt.compute.models import DiskSku from azure.mgmt.compute.models import DiskSku
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
@ -254,16 +255,16 @@ class AzureRMManagedDisk(AzureRMModuleBase):
disk_params['location'] = self.location disk_params['location'] = self.location
disk_params['tags'] = self.tags disk_params['tags'] = self.tags
if self.storage_account_type: if self.storage_account_type:
storage_account_type = self.compute_models.DiskSku(self.storage_account_type) storage_account_type = DiskSku(self.storage_account_type)
disk_params['sku'] = storage_account_type disk_params['sku'] = storage_account_type
disk_params['disk_size_gb'] = self.disk_size_gb disk_params['disk_size_gb'] = self.disk_size_gb
# TODO: Add support for EncryptionSettings # TODO: Add support for EncryptionSettings
creation_data['create_option'] = self.compute_models.DiskCreateOption.empty creation_data['create_option'] = DiskCreateOption.empty
if self.create_option == 'import': if self.create_option == 'import':
creation_data['create_option'] = self.compute_models.DiskCreateOption.import_enum creation_data['create_option'] = DiskCreateOption.import_enum
creation_data['source_uri'] = self.source_uri creation_data['source_uri'] = self.source_uri
elif self.create_option == 'copy': elif self.create_option == 'copy':
creation_data['create_option'] = self.compute_models.DiskCreateOption.copy creation_data['create_option'] = DiskCreateOption.copy
creation_data['source_resource_id'] = self.source_resource_uri creation_data['source_resource_id'] = self.source_resource_uri
try: try:
# CreationData cannot be changed after creation # CreationData cannot be changed after creation

22
lib/ansible/modules/cloud/azure/azure_rm_networkinterface.py
View file

@ -218,6 +218,8 @@ state:
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import NetworkInterface, NetworkInterfaceIPConfiguration, Subnet, \
PublicIPAddress, NetworkSecurityGroup
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -442,37 +444,37 @@ class AzureRMNetworkInterface(AzureRMModuleBase):
pip = self.create_default_pip(self.resource_group, self.location, self.name, pip = self.create_default_pip(self.resource_group, self.location, self.name,
self.public_ip_allocation_method) self.public_ip_allocation_method)
nic = self.network_models.NetworkInterface( nic = NetworkInterface(
location=self.location, location=self.location,
tags=self.tags, tags=self.tags,
ip_configurations=[ ip_configurations=[
self.network_models.NetworkInterfaceIPConfiguration( NetworkInterfaceIPConfiguration(
private_ip_allocation_method=self.private_ip_allocation_method, private_ip_allocation_method=self.private_ip_allocation_method,
) )
] ]
) )
#nic.name = self.name #nic.name = self.name
nic.ip_configurations[0].subnet = self.network_models.Subnet(id=subnet.id) nic.ip_configurations[0].subnet = Subnet(id=subnet.id)
nic.ip_configurations[0].name = 'default' nic.ip_configurations[0].name = 'default'
nic.network_security_group = self.network_models.NetworkSecurityGroup(id=nsg.id, nic.network_security_group = NetworkSecurityGroup(id=nsg.id,
location=nsg.location, location=nsg.location,
resource_guid=nsg.resource_guid) resource_guid=nsg.resource_guid)
if self.private_ip_address: if self.private_ip_address:
nic.ip_configurations[0].private_ip_address = self.private_ip_address nic.ip_configurations[0].private_ip_address = self.private_ip_address
if pip: if pip:
nic.ip_configurations[0].public_ip_address = self.network_models.PublicIPAddress( nic.ip_configurations[0].public_ip_address = PublicIPAddress(
id=pip.id, id=pip.id,
location=pip.location, location=pip.location,
resource_guid=pip.resource_guid) resource_guid=pip.resource_guid)
else: else:
self.log("Updating network interface {0}.".format(self.name)) self.log("Updating network interface {0}.".format(self.name))
nic = self.network_models.NetworkInterface( nic = NetworkInterface(
id=results['id'], id=results['id'],
location=results['location'], location=results['location'],
tags=results['tags'], tags=results['tags'],
ip_configurations=[ ip_configurations=[
self.network_models.NetworkInterfaceIPConfiguration( NetworkInterfaceIPConfiguration(
private_ip_allocation_method= private_ip_allocation_method=
results['ip_configuration']['private_ip_allocation_method'] results['ip_configuration']['private_ip_allocation_method']
) )
@ -480,7 +482,7 @@ class AzureRMNetworkInterface(AzureRMModuleBase):
) )
subnet = self.get_subnet(results['ip_configuration']['subnet']['virtual_network_name'], subnet = self.get_subnet(results['ip_configuration']['subnet']['virtual_network_name'],
results['ip_configuration']['subnet']['name']) results['ip_configuration']['subnet']['name'])
nic.ip_configurations[0].subnet = self.network_models.Subnet(id=subnet.id) nic.ip_configurations[0].subnet = Subnet(id=subnet.id)
nic.ip_configurations[0].name = results['ip_configuration']['name'] nic.ip_configurations[0].name = results['ip_configuration']['name']
#nic.name = name=results['name'], #nic.name = name=results['name'],
@ -490,7 +492,7 @@ class AzureRMNetworkInterface(AzureRMModuleBase):
if results['ip_configuration']['public_ip_address'].get('id'): if results['ip_configuration']['public_ip_address'].get('id'):
pip = \ pip = \
self.get_public_ip_address(results['ip_configuration']['public_ip_address']['name']) self.get_public_ip_address(results['ip_configuration']['public_ip_address']['name'])
nic.ip_configurations[0].public_ip_address = self.network_models.PublicIPAddress( nic.ip_configurations[0].public_ip_address = PublicIPAddress(
id=pip.id, id=pip.id,
location=pip.location, location=pip.location,
resource_guid=pip.resource_guid) resource_guid=pip.resource_guid)
@ -498,7 +500,7 @@ class AzureRMNetworkInterface(AzureRMModuleBase):
if results['network_security_group'].get('id'): if results['network_security_group'].get('id'):
nsg = self.get_security_group(results['network_security_group']['name']) nsg = self.get_security_group(results['network_security_group']['name'])
nic.network_security_group = self.network_models.NetworkSecurityGroup(id=nsg.id, nic.network_security_group = NetworkSecurityGroup(id=nsg.id,
location=nsg.location, location=nsg.location,
resource_guid=nsg.resource_guid) resource_guid=nsg.resource_guid)

9
lib/ansible/modules/cloud/azure/azure_rm_publicipaddress.py
View file

@ -114,6 +114,7 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import PublicIPAddress, PublicIPAddressDnsSettings
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -222,25 +223,25 @@ class AzureRMPublicIPAddress(AzureRMModuleBase):
if self.state == 'present': if self.state == 'present':
if not pip: if not pip:
self.log("Create new Public IP {0}".format(self.name)) self.log("Create new Public IP {0}".format(self.name))
pip = self.network_models.PublicIPAddress( pip = PublicIPAddress(
location=self.location, location=self.location,
public_ip_allocation_method=self.allocation_method, public_ip_allocation_method=self.allocation_method,
) )
if self.tags: if self.tags:
pip.tags = self.tags pip.tags = self.tags
if self.domain_name: if self.domain_name:
pip.dns_settings = self.network_models.PublicIPAddressDnsSettings( pip.dns_settings = PublicIPAddressDnsSettings(
domain_name_label=self.domain_name domain_name_label=self.domain_name
) )
else: else:
self.log("Update Public IP {0}".format(self.name)) self.log("Update Public IP {0}".format(self.name))
pip = self.network_models.PublicIPAddress( pip = PublicIPAddress(
location=results['location'], location=results['location'],
public_ip_allocation_method=results['public_ip_allocation_method'], public_ip_allocation_method=results['public_ip_allocation_method'],
tags=results['tags'] tags=results['tags']
) )
if self.domain_name: if self.domain_name:
pip.dns_settings = self.network_models.PublicIPAddressDnsSettings( pip.dns_settings = PublicIPAddressDnsSettings(
domain_name_label=self.domain_name domain_name_label=self.domain_name
) )
self.results['state'] = self.create_or_update_pip(pip) self.results['state'] = self.create_or_update_pip(pip)

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

@ -96,6 +96,7 @@ state:
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.resource.resources.models import ResourceGroup
except ImportError: except ImportError:
pass pass
@ -192,13 +193,13 @@ class AzureRMResourceGroup(AzureRMModuleBase):
if self.name_exists(): if self.name_exists():
self.fail("Error: a resource group with the name {0} already exists in your subscription." self.fail("Error: a resource group with the name {0} already exists in your subscription."
.format(self.name)) .format(self.name))
params = self.rm_models.ResourceGroup( params = ResourceGroup(
location=self.location, location=self.location,
tags=self.tags tags=self.tags
) )
else: else:
# Update resource group # Update resource group
params = self.rm_models.ResourceGroup( params = ResourceGroup(
location=results['location'], location=results['location'],
tags=results['tags'] tags=results['tags']
) )

28
lib/ansible/modules/cloud/azure/azure_rm_securitygroup.py
View file

@ -328,6 +328,12 @@ state:
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import NetworkSecurityGroup, SecurityRule
from azure.mgmt.network.models import (
SecurityRuleAccess,
SecurityRuleDirection,
SecurityRuleProtocol
)
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -336,7 +342,7 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase
from ansible.module_utils.six import integer_types from ansible.module_utils.six import integer_types
def validate_rule(self, rule, rule_type=None): def validate_rule(rule, rule_type=None):
''' '''
Apply defaults to a rule dictionary and check that all values are valid. Apply defaults to a rule dictionary and check that all values are valid.
@ -363,7 +369,7 @@ def validate_rule(self, rule, rule_type=None):
if not rule.get('access'): if not rule.get('access'):
rule['access'] = 'Allow' rule['access'] = 'Allow'
access_names = [member.value for member in self.network_models.SecurityRuleAccess] access_names = [member.value for member in SecurityRuleAccess]
if rule['access'] not in access_names: if rule['access'] not in access_names:
raise Exception("Rule access must be one of [{0}]".format(', '.join(access_names))) raise Exception("Rule access must be one of [{0}]".format(', '.join(access_names)))
@ -376,14 +382,14 @@ def validate_rule(self, rule, rule_type=None):
if not rule.get('protocol'): if not rule.get('protocol'):
rule['protocol'] = '*' rule['protocol'] = '*'
protocol_names = [member.value for member in self.network_models.SecurityRuleProtocol] protocol_names = [member.value for member in SecurityRuleProtocol]
if rule['protocol'] not in protocol_names: if rule['protocol'] not in protocol_names:
raise Exception("Rule protocol must be one of [{0}]".format(', '.join(protocol_names))) raise Exception("Rule protocol must be one of [{0}]".format(', '.join(protocol_names)))
if not rule.get('direction'): if not rule.get('direction'):
rule['direction'] = 'Inbound' rule['direction'] = 'Inbound'
direction_names = [member.value for member in self.network_models.SecurityRuleDirection] direction_names = [member.value for member in SecurityRuleDirection]
if rule['direction'] not in direction_names: if rule['direction'] not in direction_names:
raise Exception("Rule direction must be one of [{0}]".format(', '.join(direction_names))) raise Exception("Rule direction must be one of [{0}]".format(', '.join(direction_names)))
@ -423,14 +429,14 @@ def compare_rules(r, rule):
return matched, changed return matched, changed
def create_rule_instance(self, rule): def create_rule_instance(rule):
''' '''
Create an instance of SecurityRule from a dict. Create an instance of SecurityRule from a dict.
:param rule: dict :param rule: dict
:return: SecurityRule :return: SecurityRule
''' '''
return self.network_models.SecurityRule( return SecurityRule(
protocol=rule['protocol'], protocol=rule['protocol'],
source_address_prefix=rule['source_address_prefix'], source_address_prefix=rule['source_address_prefix'],
destination_address_prefix=rule['destination_address_prefix'], destination_address_prefix=rule['destination_address_prefix'],
@ -551,14 +557,14 @@ class AzureRMSecurityGroup(AzureRMModuleBase):
if self.rules: if self.rules:
for rule in self.rules: for rule in self.rules:
try: try:
validate_rule(self, rule) validate_rule(rule)
except Exception as exc: except Exception as exc:
self.fail("Error validating rule {0} - {1}".format(rule, str(exc))) self.fail("Error validating rule {0} - {1}".format(rule, str(exc)))
if self.default_rules: if self.default_rules:
for rule in self.default_rules: for rule in self.default_rules:
try: try:
validate_rule(self, rule, 'default') validate_rule(rule, 'default')
except Exception as exc: except Exception as exc:
self.fail("Error validating default rule {0} - {1}".format(rule, str(exc))) self.fail("Error validating default rule {0} - {1}".format(rule, str(exc)))
@ -672,15 +678,15 @@ class AzureRMSecurityGroup(AzureRMModuleBase):
return self.results return self.results
def create_or_update(self, results): def create_or_update(self, results):
parameters = self.network_models.NetworkSecurityGroup() parameters = NetworkSecurityGroup()
if results.get('rules'): if results.get('rules'):
parameters.security_rules = [] parameters.security_rules = []
for rule in results.get('rules'): for rule in results.get('rules'):
parameters.security_rules.append(create_rule_instance(self, rule)) parameters.security_rules.append(create_rule_instance(rule))
if results.get('default_rules'): if results.get('default_rules'):
parameters.default_security_rules = [] parameters.default_security_rules = []
for rule in results.get('default_rules'): for rule in results.get('default_rules'):
parameters.default_security_rules.append(create_rule_instance(self, rule)) parameters.default_security_rules.append(create_rule_instance(rule))
parameters.tags = results.get('tags') parameters.tags = results.get('tags')
parameters.location = results.get('location') parameters.location = results.get('location')

30
lib/ansible/modules/cloud/azure/azure_rm_storageaccount.py
View file

@ -153,6 +153,9 @@ try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.storage.cloudstorageaccount import CloudStorageAccount from azure.storage.cloudstorageaccount import CloudStorageAccount
from azure.common import AzureMissingResourceHttpError from azure.common import AzureMissingResourceHttpError
from azure.mgmt.storage.models import ProvisioningState, SkuName, SkuTier, Kind
from azure.mgmt.storage.models import StorageAccountUpdateParameters, CustomDomain, \
StorageAccountCreateParameters, Sku
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -177,7 +180,7 @@ class AzureRMStorageAccount(AzureRMModuleBase):
access_tier=dict(type='str', choices=['Hot', 'Cool']) access_tier=dict(type='str', choices=['Hot', 'Cool'])
) )
for key in self.storage_models.SkuName: for key in SkuName:
self.module_arg_spec['account_type']['choices'].append(getattr(key, 'value')) self.module_arg_spec['account_type']['choices'].append(getattr(key, 'value'))
self.results = dict( self.results = dict(
@ -319,7 +322,6 @@ class AzureRMStorageAccount(AzureRMModuleBase):
if self.account_type: if self.account_type:
if self.account_type != self.account_dict['sku_name']: if self.account_type != self.account_dict['sku_name']:
# change the account type # change the account type
SkuName = self.storage_models.SkuName
if self.account_dict['sku_name'] in [SkuName.premium_lrs, SkuName.standard_zrs]: if self.account_dict['sku_name'] in [SkuName.premium_lrs, SkuName.standard_zrs]:
self.fail("Storage accounts of type {0} and {1} cannot be changed.".format( self.fail("Storage accounts of type {0} and {1} cannot be changed.".format(
SkuName.premium_lrs, SkuName.standard_zrs)) SkuName.premium_lrs, SkuName.standard_zrs))
@ -335,9 +337,9 @@ class AzureRMStorageAccount(AzureRMModuleBase):
try: try:
self.log("sku_name: %s" % self.account_dict['sku_name']) self.log("sku_name: %s" % self.account_dict['sku_name'])
self.log("sku_tier: %s" % self.account_dict['sku_tier']) self.log("sku_tier: %s" % self.account_dict['sku_tier'])
sku = self.storage_models.Sku(SkuName(self.account_dict['sku_name'])) sku = Sku(SkuName(self.account_dict['sku_name']))
sku.tier = self.storage_models.SkuTier(self.account_dict['sku_tier']) sku.tier = SkuTier(self.account_dict['sku_tier'])
parameters = self.storage_models.StorageAccountUpdateParameters(sku=sku) parameters = StorageAccountUpdateParameters(sku=sku)
self.storage_client.storage_accounts.update(self.resource_group, self.storage_client.storage_accounts.update(self.resource_group,
self.name, self.name,
parameters) parameters)
@ -350,9 +352,9 @@ class AzureRMStorageAccount(AzureRMModuleBase):
self.account_dict['custom_domain'] = self.custom_domain self.account_dict['custom_domain'] = self.custom_domain
if self.results['changed'] and not self.check_mode: if self.results['changed'] and not self.check_mode:
new_domain = self.storage_models.CustomDomain(name=self.custom_domain['name'], new_domain = CustomDomain(name=self.custom_domain['name'],
use_sub_domain=self.custom_domain['use_sub_domain']) use_sub_domain=self.custom_domain['use_sub_domain'])
parameters = self.storage_models.StorageAccountUpdateParameters(custom_domain=new_domain) parameters = StorageAccountUpdateParameters(custom_domain=new_domain)
try: try:
self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters) self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters)
except Exception as exc: except Exception as exc:
@ -364,7 +366,7 @@ class AzureRMStorageAccount(AzureRMModuleBase):
self.account_dict['access_tier'] = self.access_tier self.account_dict['access_tier'] = self.access_tier
if self.results['changed'] and not self.check_mode: if self.results['changed'] and not self.check_mode:
parameters = self.storage_models.StorageAccountUpdateParameters(access_tier=self.access_tier) parameters = StorageAccountUpdateParameters(access_tier=self.access_tier)
try: try:
self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters) self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters)
except Exception as exc: except Exception as exc:
@ -374,7 +376,7 @@ class AzureRMStorageAccount(AzureRMModuleBase):
if update_tags: if update_tags:
self.results['changed'] = True self.results['changed'] = True
if not self.check_mode: if not self.check_mode:
parameters = self.storage_models.StorageAccountUpdateParameters(tags=self.account_dict['tags']) parameters = StorageAccountUpdateParameters(tags=self.account_dict['tags'])
try: try:
self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters) self.storage_client.storage_accounts.update(self.resource_group, self.name, parameters)
except Exception as exc: except Exception as exc:
@ -406,11 +408,9 @@ class AzureRMStorageAccount(AzureRMModuleBase):
if self.tags: if self.tags:
account_dict['tags'] = self.tags account_dict['tags'] = self.tags
return account_dict return account_dict
sku = self.storage_models.Sku(self.storage_models.SkuName(self.account_type)) sku = Sku(SkuName(self.account_type))
sku.tier = self.storage_models.SkuTier.standard if 'Standard' in self.account_type else \ sku.tier = SkuTier.standard if 'Standard' in self.account_type else SkuTier.premium
self.storage_models.SkuTier.premium parameters = StorageAccountCreateParameters(sku, self.kind, self.location, tags=self.tags, access_tier=self.access_tier)
parameters = self.storage_models.StorageAccountCreateParameters(sku, self.kind, self.location,
tags=self.tags, access_tier=self.access_tier)
self.log(str(parameters)) self.log(str(parameters))
try: try:
poller = self.storage_client.storage_accounts.create(self.resource_group, self.name, parameters) poller = self.storage_client.storage_accounts.create(self.resource_group, self.name, parameters)
@ -422,7 +422,7 @@ class AzureRMStorageAccount(AzureRMModuleBase):
return self.get_account() return self.get_account()
def delete_account(self): def delete_account(self):
if self.account_dict['provisioning_state'] == self.storage_models.ProvisioningState.succeeded.value and \ if self.account_dict['provisioning_state'] == ProvisioningState.succeeded.value and \
self.account_has_blob_containers() and self.force: self.account_has_blob_containers() and self.force:
self.fail("Account contains blob containers. Is it in use? Use the force option to attempt deletion.") self.fail("Account contains blob containers. Is it in use? Use the force option to attempt deletion.")

9
lib/ansible/modules/cloud/azure/azure_rm_subnet.py
View file

@ -126,6 +126,7 @@ from ansible.module_utils.azure_rm_common import AzureRMModuleBase, CIDR_PATTERN
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import Subnet, NetworkSecurityGroup
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -234,23 +235,23 @@ class AzureRMSubnet(AzureRMModuleBase):
if not subnet: if not subnet:
# create new subnet # create new subnet
self.log('Creating subnet {0}'.format(self.name)) self.log('Creating subnet {0}'.format(self.name))
subnet = self.network_models.Subnet( subnet = Subnet(
address_prefix=self.address_prefix_cidr address_prefix=self.address_prefix_cidr
) )
if nsg: if nsg:
subnet.network_security_group = self.network_models.NetworkSecurityGroup(id=nsg.id, subnet.network_security_group = NetworkSecurityGroup(id=nsg.id,
location=nsg.location, location=nsg.location,
resource_guid=nsg.resource_guid) resource_guid=nsg.resource_guid)
else: else:
# update subnet # update subnet
self.log('Updating subnet {0}'.format(self.name)) self.log('Updating subnet {0}'.format(self.name))
subnet = self.network_models.Subnet( subnet = Subnet(
address_prefix=results['address_prefix'] address_prefix=results['address_prefix']
) )
if results['network_security_group'].get('id'): if results['network_security_group'].get('id'):
nsg = self.get_security_group(results['network_security_group']['name']) nsg = self.get_security_group(results['network_security_group']['name'])
subnet.network_security_group = self.network_models.NetworkSecurityGroup(id=nsg.id, subnet.network_security_group = NetworkSecurityGroup(id=nsg.id,
location=nsg.location, location=nsg.location,
resource_guid=nsg.resource_guid) resource_guid=nsg.resource_guid)

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

@ -538,6 +538,17 @@ import re
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.compute.models import NetworkInterfaceReference, \
VirtualMachine, HardwareProfile, \
StorageProfile, OSProfile, OSDisk, DataDisk, \
VirtualHardDisk, ManagedDiskParameters, \
ImageReference, NetworkProfile, LinuxConfiguration, \
SshConfiguration, SshPublicKey, VirtualMachineSizeTypes, \
DiskCreateOptionTypes
from azure.mgmt.network.models import PublicIPAddress, NetworkSecurityGroup, NetworkInterface, \
NetworkInterfaceIPConfiguration, Subnet
from azure.mgmt.storage.models import StorageAccountCreateParameters, Sku
from azure.mgmt.storage.models import Kind, SkuTier, SkuName
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -828,42 +839,42 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
if not self.short_hostname: if not self.short_hostname:
self.short_hostname = self.name self.short_hostname = self.name
nics = [self.compute_models.NetworkInterfaceReference(id=id) for id in network_interfaces] nics = [NetworkInterfaceReference(id=id) for id in network_interfaces]
# os disk # os disk
if not self.managed_disk_type: if not self.managed_disk_type:
managed_disk = None managed_disk = None
vhd = self.compute_models.VirtualHardDisk(uri=requested_vhd_uri) vhd = VirtualHardDisk(uri=requested_vhd_uri)
else: else:
vhd = None vhd = None
managed_disk = self.compute_models.ManagedDiskParameters(storage_account_type=self.managed_disk_type) managed_disk = ManagedDiskParameters(storage_account_type=self.managed_disk_type)
vm_resource = self.compute_models.VirtualMachine( vm_resource = VirtualMachine(
self.location, self.location,
tags=self.tags, tags=self.tags,
os_profile=self.compute_models.OSProfile( os_profile=OSProfile(
admin_username=self.admin_username, admin_username=self.admin_username,
computer_name=self.short_hostname, computer_name=self.short_hostname,
), ),
hardware_profile=self.compute_models.HardwareProfile( hardware_profile=HardwareProfile(
vm_size=self.vm_size vm_size=self.vm_size
), ),
storage_profile=self.compute_models.StorageProfile( storage_profile=StorageProfile(
os_disk=self.compute_models.OSDisk( os_disk=OSDisk(
name=self.storage_blob_name, name=self.storage_blob_name,
vhd=vhd, vhd=vhd,
managed_disk=managed_disk, managed_disk=managed_disk,
create_option=self.compute_models.DiskCreateOptionTypes.from_image, create_option=DiskCreateOptionTypes.from_image,
caching=self.os_disk_caching, caching=self.os_disk_caching,
), ),
image_reference=self.compute_models.ImageReference( image_reference=ImageReference(
publisher=self.image['publisher'], publisher=self.image['publisher'],
offer=self.image['offer'], offer=self.image['offer'],
sku=self.image['sku'], sku=self.image['sku'],
version=self.image['version'], version=self.image['version'],
), ),
), ),
network_profile=self.compute_models.NetworkProfile( network_profile=NetworkProfile(
network_interfaces=nics network_interfaces=nics
), ),
) )
@ -872,13 +883,13 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
vm_resource.os_profile.admin_password = self.admin_password vm_resource.os_profile.admin_password = self.admin_password
if self.os_type == 'Linux': if self.os_type == 'Linux':
vm_resource.os_profile.linux_configuration = self.compute_models.LinuxConfiguration( vm_resource.os_profile.linux_configuration = LinuxConfiguration(
disable_password_authentication=disable_ssh_password disable_password_authentication=disable_ssh_password
) )
if self.ssh_public_keys: if self.ssh_public_keys:
ssh_config = self.compute_models.SshConfiguration() ssh_config = SshConfiguration()
ssh_config.public_keys = \ ssh_config.public_keys = \
[self.compute_models.SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys] [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 vm_resource.os_profile.linux_configuration.ssh = ssh_config
# data disk # data disk
@ -916,10 +927,10 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
if not data_disk.get('managed_disk_type'): if not data_disk.get('managed_disk_type'):
data_disk_managed_disk = None data_disk_managed_disk = None
disk_name = data_disk['storage_blob_name'] disk_name = data_disk['storage_blob_name']
data_disk_vhd = self.compute_models.VirtualHardDisk(uri=data_disk_requested_vhd_uri) data_disk_vhd = VirtualHardDisk(uri=data_disk_requested_vhd_uri)
else: else:
data_disk_vhd = None data_disk_vhd = None
data_disk_managed_disk = self.compute_models.ManagedDiskParameters(storage_account_type=data_disk['managed_disk_type']) data_disk_managed_disk = ManagedDiskParameters(storage_account_type=data_disk['managed_disk_type'])
disk_name = self.name + "-datadisk-" + str(count) disk_name = self.name + "-datadisk-" + str(count)
count += 1 count += 1
@ -927,12 +938,12 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
'caching', 'ReadOnly' 'caching', 'ReadOnly'
) )
data_disks.append(self.compute_models.DataDisk( data_disks.append(DataDisk(
lun=data_disk['lun'], lun=data_disk['lun'],
name=disk_name, name=disk_name,
vhd=data_disk_vhd, vhd=data_disk_vhd,
caching=data_disk['caching'], caching=data_disk['caching'],
create_option=self.compute_models.DiskCreateOptionTypes.empty, create_option=DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'], disk_size_gb=data_disk['disk_size_gb'],
managed_disk=data_disk_managed_disk, managed_disk=data_disk_managed_disk,
)) ))
@ -948,30 +959,30 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
self.log("Update virtual machine {0}".format(self.name)) self.log("Update virtual machine {0}".format(self.name))
self.results['actions'].append('Updated VM {0}'.format(self.name)) self.results['actions'].append('Updated VM {0}'.format(self.name))
nics = [self.compute_models.NetworkInterfaceReference(id=interface['id']) nics = [NetworkInterfaceReference(id=interface['id'])
for interface in vm_dict['properties']['networkProfile']['networkInterfaces']] for interface in vm_dict['properties']['networkProfile']['networkInterfaces']]
# os disk # os disk
if not vm_dict['properties']['storageProfile']['osDisk'].get('managedDisk'): if not vm_dict['properties']['storageProfile']['osDisk'].get('managedDisk'):
managed_disk = None managed_disk = None
vhd = self.compute_models.VirtualHardDisk(uri=vm_dict['properties']['storageProfile']['osDisk']['vhd']['uri']) vhd = VirtualHardDisk(uri=vm_dict['properties']['storageProfile']['osDisk']['vhd']['uri'])
else: else:
vhd = None vhd = None
managed_disk = self.compute_models.ManagedDiskParameters( managed_disk = ManagedDiskParameters(
storage_account_type=vm_dict['properties']['storageProfile']['osDisk']['managedDisk']['storageAccountType'] storage_account_type=vm_dict['properties']['storageProfile']['osDisk']['managedDisk']['storageAccountType']
) )
vm_resource = self.compute_models.VirtualMachine( vm_resource = VirtualMachine(
vm_dict['location'], vm_dict['location'],
os_profile=self.compute_models.OSProfile( os_profile=OSProfile(
admin_username=vm_dict['properties']['osProfile']['adminUsername'], admin_username=vm_dict['properties']['osProfile']['adminUsername'],
computer_name=vm_dict['properties']['osProfile']['computerName'] computer_name=vm_dict['properties']['osProfile']['computerName']
), ),
hardware_profile=self.compute_models.HardwareProfile( hardware_profile=HardwareProfile(
vm_size=vm_dict['properties']['hardwareProfile']['vmSize'] vm_size=vm_dict['properties']['hardwareProfile']['vmSize']
), ),
storage_profile=self.compute_models.StorageProfile( storage_profile=StorageProfile(
os_disk=self.compute_models.OSDisk( os_disk=OSDisk(
name=vm_dict['properties']['storageProfile']['osDisk']['name'], name=vm_dict['properties']['storageProfile']['osDisk']['name'],
vhd=vhd, vhd=vhd,
managed_disk=managed_disk, managed_disk=managed_disk,
@ -979,14 +990,14 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
os_type=vm_dict['properties']['storageProfile']['osDisk']['osType'], os_type=vm_dict['properties']['storageProfile']['osDisk']['osType'],
caching=vm_dict['properties']['storageProfile']['osDisk']['caching'], caching=vm_dict['properties']['storageProfile']['osDisk']['caching'],
), ),
image_reference=self.compute_models.ImageReference( image_reference=ImageReference(
publisher=vm_dict['properties']['storageProfile']['imageReference']['publisher'], publisher=vm_dict['properties']['storageProfile']['imageReference']['publisher'],
offer=vm_dict['properties']['storageProfile']['imageReference']['offer'], offer=vm_dict['properties']['storageProfile']['imageReference']['offer'],
sku=vm_dict['properties']['storageProfile']['imageReference']['sku'], sku=vm_dict['properties']['storageProfile']['imageReference']['sku'],
version=vm_dict['properties']['storageProfile']['imageReference']['version'] version=vm_dict['properties']['storageProfile']['imageReference']['version']
), ),
), ),
network_profile=self.compute_models.NetworkProfile( network_profile=NetworkProfile(
network_interfaces=nics network_interfaces=nics
), ),
) )
@ -1002,16 +1013,16 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
linux_config = vm_dict['properties']['osProfile'].get('linuxConfiguration') linux_config = vm_dict['properties']['osProfile'].get('linuxConfiguration')
if linux_config: if linux_config:
ssh_config = linux_config.get('ssh', None) ssh_config = linux_config.get('ssh', None)
vm_resource.os_profile.linux_configuration = self.compute_models.LinuxConfiguration( vm_resource.os_profile.linux_configuration = LinuxConfiguration(
disable_password_authentication=linux_config.get('disablePasswordAuthentication', False) disable_password_authentication=linux_config.get('disablePasswordAuthentication', False)
) )
if ssh_config: if ssh_config:
public_keys = ssh_config.get('publicKeys') public_keys = ssh_config.get('publicKeys')
if public_keys: if public_keys:
vm_resource.os_profile.linux_configuration.ssh = self.compute_models.SshConfiguration(public_keys=[]) vm_resource.os_profile.linux_configuration.ssh = SshConfiguration(public_keys=[])
for key in public_keys: for key in public_keys:
vm_resource.os_profile.linux_configuration.ssh.public_keys.append( vm_resource.os_profile.linux_configuration.ssh.public_keys.append(
self.compute_models.SshPublicKey(path=key['path'], key_data=key['keyData']) SshPublicKey(path=key['path'], key_data=key['keyData'])
) )
# data disk # data disk
@ -1021,13 +1032,13 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
for data_disk in vm_dict['properties']['storageProfile']['dataDisks']: for data_disk in vm_dict['properties']['storageProfile']['dataDisks']:
if data_disk.get('managedDisk'): if data_disk.get('managedDisk'):
managed_disk_type = data_disk['managedDisk']['storageAccountType'] managed_disk_type = data_disk['managedDisk']['storageAccountType']
data_disk_managed_disk = self.compute_models.ManagedDiskParameters(storage_account_type=managed_disk_type) data_disk_managed_disk = ManagedDiskParameters(storage_account_type=managed_disk_type)
data_disk_vhd = None data_disk_vhd = None
else: else:
data_disk_vhd = data_disk['vhd']['uri'] data_disk_vhd = data_disk['vhd']['uri']
data_disk_managed_disk = None data_disk_managed_disk = None
data_disks.append(self.compute_models.DataDisk( data_disks.append(DataDisk(
lun=int(data_disk['lun']), lun=int(data_disk['lun']),
name=data_disk.get('name'), name=data_disk.get('name'),
vhd=data_disk_vhd, vhd=data_disk_vhd,
@ -1390,10 +1401,10 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
self.log("Storage account {0} found.".format(storage_account_name)) self.log("Storage account {0} found.".format(storage_account_name))
self.check_provisioning_state(account) self.check_provisioning_state(account)
return account return account
sku = self.storage_models.Sku(self.storage_models.SkuName.standard_lrs) sku = Sku(SkuName.standard_lrs)
sku.tier = self.storage_models.SkuTier.standard Sku.tier = SkuTier.standard
kind = self.storage_models.Kind.storage kind = Kind.storage
parameters = self.storage_models.StorageAccountCreateParameters(sku, kind, self.location) parameters = StorageAccountCreateParameters(sku, kind, self.location)
self.log("Creating storage account {0} in location {1}".format(storage_account_name, self.location)) self.log("Creating storage account {0} in location {1}".format(storage_account_name, self.location))
self.results['actions'].append("Created storage account {0}".format(storage_account_name)) self.results['actions'].append("Created storage account {0}".format(storage_account_name))
try: try:
@ -1505,20 +1516,20 @@ class AzureRMVirtualMachine(AzureRMModuleBase):
group = self.create_default_securitygroup(self.resource_group, self.location, self.name, self.os_type, group = self.create_default_securitygroup(self.resource_group, self.location, self.name, self.os_type,
self.open_ports) self.open_ports)
parameters = self.network_models.NetworkInterface( parameters = NetworkInterface(
location=self.location, location=self.location,
ip_configurations=[ ip_configurations=[
self.network_models.NetworkInterfaceIPConfiguration( NetworkInterfaceIPConfiguration(
private_ip_allocation_method='Dynamic', private_ip_allocation_method='Dynamic',
) )
] ]
) )
parameters.ip_configurations[0].subnet = self.network_models.Subnet(id=subnet_id) parameters.ip_configurations[0].subnet = Subnet(id=subnet_id)
parameters.ip_configurations[0].name = 'default' parameters.ip_configurations[0].name = 'default'
parameters.network_security_group = self.network_models.NetworkSecurityGroup(id=group.id, parameters.network_security_group = NetworkSecurityGroup(id=group.id,
location=group.location, location=group.location,
resource_guid=group.resource_guid) resource_guid=group.resource_guid)
parameters.ip_configurations[0].public_ip_address = self.network_models.PublicIPAddress(id=pip.id, parameters.ip_configurations[0].public_ip_address = PublicIPAddress(id=pip.id,
location=pip.location, location=pip.location,
resource_guid=pip.resource_guid) resource_guid=pip.resource_guid)

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

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

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

@ -296,6 +296,24 @@ import re
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
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
from azure.mgmt.network.models import PublicIPAddress, \
NetworkSecurityGroup, NetworkInterface, \
NetworkInterfaceIPConfiguration, Subnet, VirtualNetwork
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
@ -503,46 +521,46 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
if not self.short_hostname: if not self.short_hostname:
self.short_hostname = self.name self.short_hostname = self.name
managed_disk = self.compute_models.VirtualMachineScaleSetManagedDiskParameters(storage_account_type=self.managed_disk_type) managed_disk = VirtualMachineScaleSetManagedDiskParameters(storage_account_type=self.managed_disk_type)
vmss_resource = self.compute_models.VirtualMachineScaleSet( vmss_resource = VirtualMachineScaleSet(
self.location, self.location,
tags=self.tags, tags=self.tags,
upgrade_policy=self.compute_models.UpgradePolicy( upgrade_policy=UpgradePolicy(
mode=self.upgrade_policy mode=self.upgrade_policy
), ),
sku=self.compute_models.Sku( sku=Sku(
name=self.vm_size, name=self.vm_size,
capacity=self.capacity, capacity=self.capacity,
tier=self.tier, tier=self.tier,
), ),
virtual_machine_profile=self.compute_models.VirtualMachineScaleSetVMProfile( virtual_machine_profile=VirtualMachineScaleSetVMProfile(
os_profile=self.compute_models.VirtualMachineScaleSetOSProfile( os_profile=VirtualMachineScaleSetOSProfile(
admin_username=self.admin_username, admin_username=self.admin_username,
computer_name_prefix=self.short_hostname, computer_name_prefix=self.short_hostname,
), ),
storage_profile=self.compute_models.VirtualMachineScaleSetStorageProfile( storage_profile=VirtualMachineScaleSetStorageProfile(
os_disk=self.compute_models.VirtualMachineScaleSetOSDisk( os_disk=VirtualMachineScaleSetOSDisk(
managed_disk=managed_disk, managed_disk=managed_disk,
create_option=self.compute_models.DiskCreateOptionTypes.from_image, create_option=DiskCreateOptionTypes.from_image,
caching=self.os_disk_caching, caching=self.os_disk_caching,
), ),
image_reference=self.compute_models.ImageReference( image_reference=ImageReference(
publisher=self.image['publisher'], publisher=self.image['publisher'],
offer=self.image['offer'], offer=self.image['offer'],
sku=self.image['sku'], sku=self.image['sku'],
version=self.image['version'], version=self.image['version'],
), ),
), ),
network_profile=self.compute_models.VirtualMachineScaleSetNetworkProfile( network_profile=VirtualMachineScaleSetNetworkProfile(
network_interface_configurations=[ network_interface_configurations=[
self.compute_models.VirtualMachineScaleSetNetworkConfiguration( VirtualMachineScaleSetNetworkConfiguration(
name=self.name, name=self.name,
primary=True, primary=True,
ip_configurations=[ ip_configurations=[
self.compute_models.VirtualMachineScaleSetIPConfiguration( VirtualMachineScaleSetIPConfiguration(
name='default', name='default',
subnet=self.compute_models.ApiEntityReference( subnet=ApiEntityReference(
id=subnet.id id=subnet.id
) )
) )
@ -557,33 +575,33 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
vmss_resource.virtual_machine_profile.os_profile.admin_password = self.admin_password vmss_resource.virtual_machine_profile.os_profile.admin_password = self.admin_password
if self.os_type == 'Linux': if self.os_type == 'Linux':
vmss_resource.virtual_machine_profile.os_profile.linux_configuration = self.compute_models.LinuxConfiguration( vmss_resource.virtual_machine_profile.os_profile.linux_configuration = LinuxConfiguration(
disable_password_authentication=disable_ssh_password disable_password_authentication=disable_ssh_password
) )
if self.ssh_public_keys: if self.ssh_public_keys:
ssh_config = self.compute_models.SshConfiguration() ssh_config = SshConfiguration()
ssh_config.public_keys = \ ssh_config.public_keys = \
[self.compute_models.SshPublicKey(path=key['path'], key_data=key['key_data']) for key in self.ssh_public_keys] [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 vmss_resource.virtual_machine_profile.os_profile.linux_configuration.ssh = ssh_config
if self.data_disks: if self.data_disks:
data_disks = [] data_disks = []
for data_disk in self.data_disks: for data_disk in self.data_disks:
data_disk_managed_disk = self.compute_models.VirtualMachineScaleSetManagedDiskParameters( data_disk_managed_disk = VirtualMachineScaleSetManagedDiskParameters(
storage_account_type=data_disk['managed_disk_type'] storage_account_type=data_disk['managed_disk_type']
) )
data_disk['caching'] = data_disk.get( data_disk['caching'] = data_disk.get(
'caching', 'caching',
self.compute_models.CachingTypes.read_only CachingTypes.read_only
) )
data_disks.append(self.compute_models.VirtualMachineScaleSetDataDisk( data_disks.append(VirtualMachineScaleSetDataDisk(
lun=data_disk['lun'], lun=data_disk['lun'],
caching=data_disk['caching'], caching=data_disk['caching'],
create_option=self.compute_models.DiskCreateOptionTypes.empty, create_option=DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'], disk_size_gb=data_disk['disk_size_gb'],
managed_disk=data_disk_managed_disk, managed_disk=data_disk_managed_disk,
)) ))
@ -603,12 +621,12 @@ class AzureRMVirtualMachineScaleSet(AzureRMModuleBase):
data_disks = [] data_disks = []
for data_disk in self.data_disks: for data_disk in self.data_disks:
data_disks.append(self.compute_models.VirtualMachineScaleSetDataDisk( data_disks.append(VirtualMachineScaleSetDataDisk(
lun=data_disk['lun'], lun=data_disk['lun'],
caching=data_disk['caching'], caching=data_disk['caching'],
create_option=self.compute_models.DiskCreateOptionTypes.empty, create_option=DiskCreateOptionTypes.empty,
disk_size_gb=data_disk['disk_size_gb'], disk_size_gb=data_disk['disk_size_gb'],
managed_disk=self.compute_models.VirtualMachineScaleSetManagedDiskParameters( managed_disk=VirtualMachineScaleSetManagedDiskParameters(
storage_account_type=data_disk['managed_disk_type'] storage_account_type=data_disk['managed_disk_type']
), ),
)) ))

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

@ -129,6 +129,7 @@ state:
try: try:
from msrestazure.azure_exceptions import CloudError from msrestazure.azure_exceptions import CloudError
from azure.mgmt.network.models import VirtualNetwork, AddressSpace, DhcpOptions
except ImportError: except ImportError:
# This is handled in azure_rm_common # This is handled in azure_rm_common
pass pass
@ -294,14 +295,14 @@ class AzureRMVirtualNetwork(AzureRMModuleBase):
self.log("Create virtual network {0}".format(self.name)) self.log("Create virtual network {0}".format(self.name))
if not self.address_prefixes_cidr: if not self.address_prefixes_cidr:
self.fail('Parameter error: address_prefixes_cidr required when creating a virtual network') self.fail('Parameter error: address_prefixes_cidr required when creating a virtual network')
vnet = self.network_models.VirtualNetwork( vnet = VirtualNetwork(
location=self.location, location=self.location,
address_space=self.network_models.AddressSpace( address_space=AddressSpace(
address_prefixes=self.address_prefixes_cidr address_prefixes=self.address_prefixes_cidr
) )
) )
if self.dns_servers: if self.dns_servers:
vnet.dhcp_options = self.network_models.DhcpOptions( vnet.dhcp_options = DhcpOptions(
dns_servers=self.dns_servers dns_servers=self.dns_servers
) )
if self.tags: if self.tags:
@ -310,15 +311,15 @@ class AzureRMVirtualNetwork(AzureRMModuleBase):
else: else:
# update existing virtual network # update existing virtual network
self.log("Update virtual network {0}".format(self.name)) self.log("Update virtual network {0}".format(self.name))
vnet = self.network_models.VirtualNetwork( vnet = VirtualNetwork(
location=results['location'], location=results['location'],
address_space=self.network_models.AddressSpace( address_space=AddressSpace(
address_prefixes=results['address_prefixes'] address_prefixes=results['address_prefixes']
), ),
tags=results['tags'] tags=results['tags']
) )
if results.get('dns_servers'): if results.get('dns_servers'):
vnet.dhcp_options = self.network_models.DhcpOptions( vnet.dhcp_options = DhcpOptions(
dns_servers=results['dns_servers'] dns_servers=results['dns_servers']
) )
self.results['state'] = self.create_or_update_vnet(vnet) self.results['state'] = self.create_or_update_vnet(vnet)