openstack
/
heat
Code Issues Proposed changes

Use default client name for neutron resources 

Use default client name for neutron resources instead of
self.neutron() to provide a single way of client usage.

Change-Id: Ib18c18df1ac79b787ca51131cb02c2486198ae87
This commit is contained in:
huangtianhua 2015-08-27 17:37:26 +08:00
parent d5c02aaba0
commit c43e8a6410
18 changed files with 146 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
heat/engine/resources/aws/ec2/internet_gateway.py
View File

@ -118,17 +118,16 @@ class VPCGatewayAttachment(resource.Resource):
deps += (self, route_tbl)
def handle_create(self):
client = self.neutron()
client = self.client()
external_network_id = InternetGateway.get_external_network_id(client)
for router in self._vpc_route_tables():
client.add_gateway_router(router.resource_id, {
'network_id': external_network_id})
def handle_delete(self):
client = self.neutron()
for router in self._vpc_route_tables():
try:
client.remove_gateway_router(router.resource_id)
self.client().remove_gateway_router(router.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)

14
heat/engine/resources/aws/ec2/network_interface.py
View File

@ -105,8 +105,6 @@ class NetworkInterface(resource.Resource):
self.fixed_ip_address = None
def handle_create(self):
client = self.neutron()
subnet_id = self.properties[self.SUBNET_ID]
network_id = self.client_plugin().network_id_from_subnet_id(
subnet_id)
@ -129,16 +127,15 @@ class NetworkInterface(resource.Resource):
sgs = self.client_plugin().get_secgroup_uuids(
self.properties.get(self.GROUP_SET))
props['security_groups'] = sgs
port = client.create_port({'port': props})['port']
port = self.client().create_port({'port': props})['port']
self.resource_id_set(port['id'])
def handle_delete(self):
if self.resource_id is None:
return
client = self.neutron()
try:
client.delete_port(self.resource_id)
self.client().delete_port(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
@ -158,14 +155,13 @@ class NetworkInterface(resource.Resource):
update_props['security_groups'] = sgs
self.neutron().update_port(self.resource_id,
{'port': update_props})
self.client().update_port(self.resource_id,
{'port': update_props})
def _get_fixed_ip_address(self, ):
if self.fixed_ip_address is None:
client = self.neutron()
try:
port = client.show_port(self.resource_id)['port']
port = self.client().show_port(self.resource_id)['port']
if port['fixed_ips'] and len(port['fixed_ips']) > 0:
self.fixed_ip_address = port['fixed_ips'][0]['ip_address']
except Exception as ex:

14
heat/engine/resources/aws/ec2/subnet.py
View File

@ -82,7 +82,6 @@ class Subnet(resource.Resource):
default_client_name = 'neutron'
def handle_create(self):
client = self.neutron()
# TODO(sbaker) Verify that this CidrBlock is within the vpc CidrBlock
network_id = self.properties.get(self.VPC_ID)
@ -92,12 +91,12 @@ class Subnet(resource.Resource):
'name': self.physical_resource_name(),
'ip_version': 4
}
subnet = client.create_subnet({'subnet': props})['subnet']
subnet = self.client().create_subnet({'subnet': props})['subnet']
self.resource_id_set(subnet['id'])
router = vpc.VPC.router_for_vpc(self.neutron(), network_id)
router = vpc.VPC.router_for_vpc(self.client(), network_id)
if router:
client.add_interface_router(
self.client().add_interface_router(
router['id'],
{'subnet_id': subnet['id']})
@ -105,21 +104,20 @@ class Subnet(resource.Resource):
if self.resource_id is None:
return
client = self.neutron()
network_id = self.properties.get(self.VPC_ID)
subnet_id = self.resource_id
try:
router = vpc.VPC.router_for_vpc(self.neutron(), network_id)
router = vpc.VPC.router_for_vpc(self.client(), network_id)
if router:
client.remove_interface_router(
self.client().remove_interface_router(
router['id'],
{'subnet_id': subnet_id})
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
try:
client.delete_subnet(subnet_id)
self.client().delete_subnet(subnet_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)

16
heat/engine/resources/aws/ec2/vpc.py
View File

@ -73,14 +73,13 @@ class VPC(resource.Resource):
default_client_name = 'neutron'
def handle_create(self):
client = self.neutron()
# The VPC's net and router are associated by having identical names.
net_props = {'name': self.physical_resource_name()}
router_props = {'name': self.physical_resource_name()}
net = client.create_network({'network': net_props})['network']
net = self.client().create_network({'network': net_props})['network']
self.resource_id_set(net['id'])
client.create_router({'router': router_props})['router']
self.client().create_router({'router': router_props})['router']
@staticmethod
def network_for_vpc(client, network_id):
@ -102,26 +101,25 @@ class VPC(resource.Resource):
return routers[0]
def check_create_complete(self, *args):
net = self.network_for_vpc(self.neutron(), self.resource_id)
net = self.network_for_vpc(self.client(), self.resource_id)
if not neutron.NeutronResource.is_built(net):
return False
router = self.router_for_vpc(self.neutron(), self.resource_id)
router = self.router_for_vpc(self.client(), self.resource_id)
return neutron.NeutronResource.is_built(router)
def handle_delete(self):
if self.resource_id is None:
return
client = self.neutron()
try:
router = self.router_for_vpc(client, self.resource_id)
router = self.router_for_vpc(self.client(), self.resource_id)
if router:
client.delete_router(router['id'])
self.client().delete_router(router['id'])
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
try:
client.delete_network(self.resource_id)
self.client().delete_network(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)

12
heat/engine/resources/openstack/neutron/extraroute.py
View File

@ -71,7 +71,7 @@ class ExtraRoute(neutron.NeutronResource):
def handle_create(self):
router_id = self.properties.get(self.ROUTER_ID)
routes = self.neutron().show_router(
routes = self.client().show_router(
router_id).get('router').get('routes')
if not routes:
routes = []
@ -81,8 +81,8 @@ class ExtraRoute(neutron.NeutronResource):
msg = _('Route duplicates an existing route.')
raise exception.Error(msg)
routes.append(new_route)
self.neutron().update_router(router_id, {'router':
{'routes': routes}})
self.client().update_router(router_id,
{'router': {'routes': routes}})
new_route['router_id'] = router_id
self.resource_id_set(
'%(router_id)s:%(destination)s:%(nexthop)s' % new_route)
@ -92,15 +92,15 @@ class ExtraRoute(neutron.NeutronResource):
return
(router_id, destination, nexthop) = self.resource_id.split(':')
try:
routes = self.neutron().show_router(
routes = self.client().show_router(
router_id).get('router').get('routes', [])
try:
routes.remove({'destination': destination,
'nexthop': nexthop})
except ValueError:
return
self.neutron().update_router(router_id, {'router':
{'routes': routes}})
self.client().update_router(router_id,
{'router': {'routes': routes}})
except Exception as ex:
self.client_plugin().ignore_not_found(ex)

27
heat/engine/resources/openstack/neutron/firewall.py
View File

@ -110,25 +110,24 @@ class Firewall(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_firewall(self.resource_id)['firewall']
return self.client().show_firewall(self.resource_id)['firewall']
def handle_create(self):
props = self.prepare_properties(
self.properties,
self.physical_resource_name())
firewall = self.neutron().create_firewall({'firewall': props})[
firewall = self.client().create_firewall({'firewall': props})[
'firewall']
self.resource_id_set(firewall['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_firewall(
self.client().update_firewall(
self.resource_id, {'firewall': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_firewall(self.resource_id)
self.client().delete_firewall(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -217,26 +216,25 @@ class FirewallPolicy(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_firewall_policy(self.resource_id)[
return self.client().show_firewall_policy(self.resource_id)[
'firewall_policy']
def handle_create(self):
props = self.prepare_properties(
self.properties,
self.physical_resource_name())
firewall_policy = self.neutron().create_firewall_policy(
firewall_policy = self.client().create_firewall_policy(
{'firewall_policy': props})['firewall_policy']
self.resource_id_set(firewall_policy['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_firewall_policy(
self.client().update_firewall_policy(
self.resource_id, {'firewall_policy': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_firewall_policy(self.resource_id)
self.client().delete_firewall_policy(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -409,7 +407,7 @@ class FirewallRule(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_firewall_rule(
return self.client().show_firewall_rule(
self.resource_id)['firewall_rule']
def handle_create(self):
@ -418,7 +416,7 @@ class FirewallRule(neutron.NeutronResource):
self.physical_resource_name())
if props.get(self.PROTOCOL) == 'any':
props[self.PROTOCOL] = None
firewall_rule = self.neutron().create_firewall_rule(
firewall_rule = self.client().create_firewall_rule(
{'firewall_rule': props})['firewall_rule']
self.resource_id_set(firewall_rule['id'])
@ -426,13 +424,12 @@ class FirewallRule(neutron.NeutronResource):
if prop_diff:
if prop_diff.get(self.PROTOCOL) == 'any':
prop_diff[self.PROTOCOL] = None
self.neutron().update_firewall_rule(
self.client().update_firewall_rule(
self.resource_id, {'firewall_rule': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_firewall_rule(self.resource_id)
self.client().delete_firewall_rule(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:

24
heat/engine/resources/openstack/neutron/floatingip.py
View File

@ -167,7 +167,7 @@ class FloatingIP(neutron.NeutronResource):
p_net = (resource.properties.get(port.Port.NETWORK) or
resource.properties.get(port.Port.NETWORK_ID))
if p_net and p_net != 'None':
subnets = self.neutron().show_network(p_net)[
subnets = self.client().show_network(p_net)[
'network']['subnets']
return subnet in subnets
else:
@ -221,24 +221,21 @@ class FloatingIP(neutron.NeutronResource):
self.physical_resource_name())
self.client_plugin().resolve_network(props, self.FLOATING_NETWORK,
'floating_network_id')
fip = self.neutron().create_floatingip({
fip = self.client().create_floatingip({
'floatingip': props})['floatingip']
self.resource_id_set(fip['id'])
def _show_resource(self):
return self.neutron().show_floatingip(self.resource_id)['floatingip']
return self.client().show_floatingip(self.resource_id)['floatingip']
def handle_delete(self):
client = self.neutron()
try:
client.delete_floatingip(self.resource_id)
self.client().delete_floatingip(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
neutron_client = self.neutron()
port_id = prop_diff.get(self.PORT_ID,
self.properties[self.PORT_ID])
@ -251,7 +248,7 @@ class FloatingIP(neutron.NeutronResource):
'port_id': port_id,
'fixed_ip_address': fixed_ip_address}}
neutron_client.update_floatingip(self.resource_id, request_body)
self.client().update_floatingip(self.resource_id, request_body)
class FloatingIPAssociation(neutron.NeutronResource):
@ -319,16 +316,16 @@ class FloatingIPAssociation(neutron.NeutronResource):
floatingip_id = props.pop(self.FLOATINGIP_ID)
self.neutron().update_floatingip(floatingip_id, {
self.client().update_floatingip(floatingip_id, {
'floatingip': props})
self.resource_id_set(self.id)
def handle_delete(self):
if not self.resource_id:
return
client = self.neutron()
try:
client.update_floatingip(
self.client().update_floatingip(
self.properties[self.FLOATINGIP_ID],
{'floatingip': {'port_id': None}})
except Exception as ex:
@ -338,12 +335,11 @@ class FloatingIPAssociation(neutron.NeutronResource):
if prop_diff:
floatingip_id = self.properties[self.FLOATINGIP_ID]
port_id = self.properties[self.PORT_ID]
neutron_client = self.neutron()
# if the floatingip_id is changed, disassociate the port which
# associated with the old floatingip_id
if self.FLOATINGIP_ID in prop_diff:
try:
neutron_client.update_floatingip(
self.client().update_floatingip(
floatingip_id,
{'floatingip': {'port_id': None}})
except Exception as ex:
@ -362,7 +358,7 @@ class FloatingIPAssociation(neutron.NeutronResource):
'port_id': port_id,
'fixed_ip_address': fixed_ip_address}}
neutron_client.update_floatingip(floatingip_id, request_body)
self.client().update_floatingip(floatingip_id, request_body)
self.resource_id_set(self.id)

60
heat/engine/resources/openstack/neutron/loadbalancer.py
View File

@ -150,22 +150,22 @@ class HealthMonitor(neutron.NeutronResource):
properties = self.prepare_properties(
self.properties,
self.physical_resource_name())
health_monitor = self.neutron().create_health_monitor(
health_monitor = self.client().create_health_monitor(
{'health_monitor': properties})['health_monitor']
self.resource_id_set(health_monitor['id'])
def _show_resource(self):
return self.neutron().show_health_monitor(
return self.client().show_health_monitor(
self.resource_id)['health_monitor']
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_health_monitor(
self.client().update_health_monitor(
self.resource_id, {'health_monitor': prop_diff})
def handle_delete(self):
try:
self.neutron().delete_health_monitor(self.resource_id)
self.client().delete_health_monitor(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -426,12 +426,12 @@ class Pool(neutron.NeutronResource):
properties, self.SUBNET, 'subnet_id')
vip_properties = properties.pop(self.VIP)
monitors = properties.pop(self.MONITORS)
client = self.neutron()
pool = client.create_pool({'pool': properties})['pool']
pool = self.client().create_pool({'pool': properties})['pool']
self.resource_id_set(pool['id'])
for monitor in monitors:
client.associate_health_monitor(
self.client().associate_health_monitor(
pool['id'], {'health_monitor': {'id': monitor}})
vip_arguments = self.prepare_properties(
@ -452,12 +452,12 @@ class Pool(neutron.NeutronResource):
vip_arguments, self.VIP_SUBNET, 'subnet_id')
vip_arguments['pool_id'] = pool['id']
vip = client.create_vip({'vip': vip_arguments})['vip']
vip = self.client().create_vip({'vip': vip_arguments})['vip']
self.metadata_set({'vip': vip['id']})
def _show_resource(self):
return self.neutron().show_pool(self.resource_id)['pool']
return self.client().show_pool(self.resource_id)['pool']
def check_create_complete(self, data):
attributes = self._show_resource()
@ -465,7 +465,7 @@ class Pool(neutron.NeutronResource):
if status == 'PENDING_CREATE':
return False
elif status == 'ACTIVE':
vip_attributes = self.neutron().show_vip(
vip_attributes = self.client().show_vip(
self.metadata_get()['vip'])['vip']
vip_status = vip_attributes['status']
if vip_status == 'PENDING_CREATE':
@ -490,27 +490,26 @@ class Pool(neutron.NeutronResource):
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
client = self.neutron()
if self.MONITORS in prop_diff:
monitors = set(prop_diff.pop(self.MONITORS))
old_monitors = set(self.properties[self.MONITORS])
for monitor in old_monitors - monitors:
client.disassociate_health_monitor(self.resource_id,
monitor)
self.client().disassociate_health_monitor(
self.resource_id, monitor)
for monitor in monitors - old_monitors:
client.associate_health_monitor(
self.client().associate_health_monitor(
self.resource_id, {'health_monitor': {'id': monitor}})
if prop_diff:
client.update_pool(self.resource_id, {'pool': prop_diff})
self.client().update_pool(self.resource_id,
{'pool': prop_diff})
def _resolve_attribute(self, name):
if name == self.VIP_ATTR:
return self.neutron().show_vip(self.metadata_get()['vip'])['vip']
return self.client().show_vip(self.metadata_get()['vip'])['vip']
return super(Pool, self)._resolve_attribute(name)
def handle_delete(self):
if not self.resource_id:
prg = progress.PoolDeleteProgress(True)
return prg
@ -523,15 +522,15 @@ class Pool(neutron.NeutronResource):
def _delete_vip(self):
return self._not_found_in_call(
self.neutron().delete_vip, self.metadata_get()['vip'])
self.client().delete_vip, self.metadata_get()['vip'])
def _check_vip_deleted(self):
return self._not_found_in_call(
self.neutron().show_vip, self.metadata_get()['vip'])
self.client().show_vip, self.metadata_get()['vip'])
def _delete_pool(self):
return self._not_found_in_call(
self.neutron().delete_pool, self.resource_id)
self.client().delete_pool, self.resource_id)
def check_delete_complete(self, prg):
if not prg.vip['delete_called']:
@ -641,7 +640,6 @@ class PoolMember(neutron.NeutronResource):
def handle_create(self):
pool = self.properties[self.POOL_ID]
client = self.neutron()
protocol_port = self.properties[self.PROTOCOL_PORT]
address = self.properties[self.ADDRESS]
admin_state_up = self.properties[self.ADMIN_STATE_UP]
@ -657,21 +655,20 @@ class PoolMember(neutron.NeutronResource):
if weight is not None:
params['weight'] = weight
member = client.create_member({'member': params})['member']
member = self.client().create_member({'member': params})['member']
self.resource_id_set(member['id'])
def _show_resource(self):
return self.neutron().show_member(self.resource_id)['member']
return self.client().show_member(self.resource_id)['member']
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_member(
self.client().update_member(
self.resource_id, {'member': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_member(self.resource_id)
self.client().delete_member(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -715,12 +712,11 @@ class LoadBalancer(resource.Resource):
def handle_create(self):
pool = self.properties[self.POOL_ID]
client = self.neutron()
protocol_port = self.properties[self.PROTOCOL_PORT]
for member in self.properties[self.MEMBERS] or []:
address = self.client_plugin('nova').server_to_ipaddress(member)
lb_member = client.create_member({
lb_member = self.client().create_member({
'member': {
'pool_id': pool,
'address': address,
@ -742,11 +738,10 @@ class LoadBalancer(resource.Resource):
members = set(new_props[self.MEMBERS] or [])
rd_members = self.data()
old_members = set(six.iterkeys(rd_members))
client = self.neutron()
for member in old_members - members:
member_id = rd_members[member]
try:
client.delete_member(member_id)
self.client().delete_member(member_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
self.data_delete(member)
@ -755,7 +750,7 @@ class LoadBalancer(resource.Resource):
for member in members - old_members:
address = self.client_plugin('nova').server_to_ipaddress(
member)
lb_member = client.create_member({
lb_member = self.client().create_member({
'member': {
'pool_id': pool,
'address': address,
@ -763,12 +758,11 @@ class LoadBalancer(resource.Resource):
self.data_set(member, lb_member['id'])
def handle_delete(self):
client = self.neutron()
# FIXME(pshchelo): this deletes members in a tight loop,
# so is prone to OverLimit bug similar to LP 1265937
for member, member_id in self.data().items():
try:
client.delete_member(member_id)
self.client().delete_member(member_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
self.data_delete(member)

12
heat/engine/resources/openstack/neutron/metering.py
View File

@ -76,18 +76,18 @@ class MeteringLabel(neutron.NeutronResource):
self.properties,
self.physical_resource_name())
metering_label = self.neutron().create_metering_label(
metering_label = self.client().create_metering_label(
{'metering_label': props})['metering_label']
self.resource_id_set(metering_label['id'])
def _show_resource(self):
return self.neutron().show_metering_label(
return self.client().show_metering_label(
self.resource_id)['metering_label']
def handle_delete(self):
try:
self.neutron().delete_metering_label(self.resource_id)
self.client().delete_metering_label(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -168,18 +168,18 @@ class MeteringRule(neutron.NeutronResource):
self.properties,
self.physical_resource_name())
metering_label_rule = self.neutron().create_metering_label_rule(
metering_label_rule = self.client().create_metering_label_rule(
{'metering_label_rule': props})['metering_label_rule']
self.resource_id_set(metering_label_rule['id'])
def _show_resource(self):
return self.neutron().show_metering_label_rule(
return self.client().show_metering_label_rule(
self.resource_id)['metering_label_rule']
def handle_delete(self):
try:
self.neutron().delete_metering_label_rule(self.resource_id)
self.client().delete_metering_label_rule(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:

15
heat/engine/resources/openstack/neutron/net.py
View File

@ -128,14 +128,14 @@ class Net(neutron.NeutronResource):
dhcp_agent_ids = props.pop(self.DHCP_AGENT_IDS, None)
net = self.neutron().create_network({'network': props})['network']
net = self.client().create_network({'network': props})['network']
self.resource_id_set(net['id'])
if dhcp_agent_ids:
self._replace_dhcp_agents(dhcp_agent_ids)
def _show_resource(self):
return self.neutron().show_network(
return self.client().show_network(
self.resource_id)['network']
def check_create_complete(self, *args):
@ -143,9 +143,8 @@ class Net(neutron.NeutronResource):
return self.is_built(attributes)
def handle_delete(self):
client = self.neutron()
try:
client.delete_network(self.resource_id)
self.client().delete_network(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -162,7 +161,7 @@ class Net(neutron.NeutronResource):
del prop_diff[self.DHCP_AGENT_IDS]
if len(prop_diff) > 0:
self.neutron().update_network(
self.client().update_network(
self.resource_id, {'network': props})
def check_update_complete(self, *args):
@ -170,14 +169,14 @@ class Net(neutron.NeutronResource):
return self.is_built(attributes)
def _replace_dhcp_agents(self, dhcp_agent_ids):
ret = self.neutron().list_dhcp_agent_hosting_networks(
ret = self.client().list_dhcp_agent_hosting_networks(
self.resource_id)
old = set([agent['id'] for agent in ret['agents']])
new = set(dhcp_agent_ids)
for dhcp_agent_id in new - old:
try:
self.neutron().add_network_to_dhcp_agent(
self.client().add_network_to_dhcp_agent(
dhcp_agent_id, {'network_id': self.resource_id})
except Exception as ex:
# if 409 is happened, the agent is already associated.
@ -186,7 +185,7 @@ class Net(neutron.NeutronResource):
for dhcp_agent_id in old - new:
try:
self.neutron().remove_network_from_dhcp_agent(
self.client().remove_network_from_dhcp_agent(
dhcp_agent_id, self.resource_id)
except Exception as ex:
# assume 2 patterns about status_code following:

17
heat/engine/resources/openstack/neutron/network_gateway.py
View File

@ -159,7 +159,7 @@ class NetworkGateway(neutron.NeutronResource):
]
def _show_resource(self):
return self.neutron().show_network_gateway(
return self.client().show_network_gateway(
self.resource_id)['network_gateway']
def validate(self):
@ -191,7 +191,7 @@ class NetworkGateway(neutron.NeutronResource):
self.physical_resource_name())
connections = props.pop(self.CONNECTIONS)
ret = self.neutron().create_network_gateway(
ret = self.client().create_network_gateway(
{'network_gateway': props})['network_gateway']
self.resource_id_set(ret['id'])
@ -201,14 +201,13 @@ class NetworkGateway(neutron.NeutronResource):
connection, self.NETWORK, 'network_id')
if self.NETWORK in six.iterkeys(connection):
connection.pop(self.NETWORK)
self.neutron().connect_network_gateway(
self.client().connect_network_gateway(
ret['id'], connection
)
def handle_delete(self):
if not self.resource_id:
return
client = self.neutron()
connections = self.properties[self.CONNECTIONS]
for connection in connections:
@ -217,14 +216,14 @@ class NetworkGateway(neutron.NeutronResource):
connection, self.NETWORK, 'network_id')
if self.NETWORK in six.iterkeys(connection):
connection.pop(self.NETWORK)
client.disconnect_network_gateway(
self.client().disconnect_network_gateway(
self.resource_id, connection
)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
try:
client.delete_network_gateway(self.resource_id)
self.client().delete_network_gateway(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -243,7 +242,7 @@ class NetworkGateway(neutron.NeutronResource):
props.pop(self.DEVICES, None)
if self.NAME in prop_diff:
self.neutron().update_network_gateway(
self.client().update_network_gateway(
self.resource_id, {'network_gateway': props})
if self.CONNECTIONS in prop_diff:
@ -253,7 +252,7 @@ class NetworkGateway(neutron.NeutronResource):
connection, self.NETWORK, 'network_id')
if self.NETWORK in six.iterkeys(connection):
connection.pop(self.NETWORK)
self.neutron().disconnect_network_gateway(
self.client().disconnect_network_gateway(
self.resource_id, connection
)
except Exception as ex:
@ -263,7 +262,7 @@ class NetworkGateway(neutron.NeutronResource):
connection, self.NETWORK, 'network_id')
if self.NETWORK in six.iterkeys(connection):
connection.pop(self.NETWORK)
self.neutron().connect_network_gateway(
self.client().connect_network_gateway(
self.resource_id, connection
)

11
heat/engine/resources/openstack/neutron/port.py
View File

@ -343,7 +343,7 @@ class Port(neutron.NeutronResource):
self.client_plugin().resolve_network(props, self.NETWORK, 'network_id')
self._prepare_port_properties(props)
port = self.neutron().create_port({'port': props})['port']
port = self.client().create_port({'port': props})['port']
self.resource_id_set(port['id'])
def _prepare_port_properties(self, props, prepare_for_update=False):
@ -380,7 +380,7 @@ class Port(neutron.NeutronResource):
del(props[self.REPLACEMENT_POLICY])
def _show_resource(self):
return self.neutron().show_port(
return self.client().show_port(
self.resource_id)['port']
def check_create_complete(self, *args):
@ -388,9 +388,8 @@ class Port(neutron.NeutronResource):
return self.is_built(attributes)
def handle_delete(self):
client = self.neutron()
try:
client.delete_port(self.resource_id)
self.client().delete_port(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -404,7 +403,7 @@ class Port(neutron.NeutronResource):
for fixed_ip in fixed_ips:
subnet_id = fixed_ip.get('subnet_id')
if subnet_id:
subnets.append(self.neutron().show_subnet(
subnets.append(self.client().show_subnet(
subnet_id)['subnet'])
except Exception as ex:
LOG.warn(_LW("Failed to fetch resource attributes: %s"), ex)
@ -426,7 +425,7 @@ class Port(neutron.NeutronResource):
self._prepare_port_properties(props, prepare_for_update=True)
LOG.debug('updating port with %s' % props)
self.neutron().update_port(self.resource_id, {'port': props})
self.client().update_port(self.resource_id, {'port': props})
def check_update_complete(self, *args):
attributes = self._show_resource()

4
heat/engine/resources/openstack/neutron/provider_net.py
View File

@ -120,7 +120,7 @@ class ProviderNet(net.Net):
self.prepare_provider_properties(self, props)
prov_net = self.neutron().create_network({'network': props})['network']
prov_net = self.client().create_network({'network': props})['network']
self.resource_id_set(prov_net['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
@ -131,7 +131,7 @@ class ProviderNet(net.Net):
self.prepare_provider_properties(self, props)
self.neutron().update_network(self.resource_id, {'network': props})
self.client().update_network(self.resource_id, {'network': props})
def resource_mapping():

26
heat/engine/resources/openstack/neutron/router.py
View File

@ -209,14 +209,14 @@ class Router(neutron.NeutronResource):
l3_agent_ids = self._get_l3_agent_list(props)
router = self.neutron().create_router({'router': props})['router']
router = self.client().create_router({'router': props})['router']
self.resource_id_set(router['id'])
if l3_agent_ids:
self._replace_agent(l3_agent_ids)
def _show_resource(self):
return self.neutron().show_router(
return self.client().show_router(
self.resource_id)['router']
def check_create_complete(self, *args):
@ -224,9 +224,8 @@ class Router(neutron.NeutronResource):
return self.is_built(attributes)
def handle_delete(self):
client = self.neutron()
try:
client.delete_router(self.resource_id)
self.client().delete_router(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -244,18 +243,18 @@ class Router(neutron.NeutronResource):
del prop_diff[self.L3_AGENT_ID]
if len(prop_diff) > 0:
self.neutron().update_router(
self.client().update_router(
self.resource_id, {'router': props})
def _replace_agent(self, l3_agent_ids=None):
ret = self.neutron().list_l3_agent_hosting_routers(
ret = self.client().list_l3_agent_hosting_routers(
self.resource_id)
for agent in ret['agents']:
self.neutron().remove_router_from_l3_agent(
self.client().remove_router_from_l3_agent(
agent['id'], self.resource_id)
if l3_agent_ids:
for l3_agent_id in l3_agent_ids:
self.neutron().add_router_to_l3_agent(
self.client().add_router_to_l3_agent(
l3_agent_id, {'router_id': self.resource_id})
@ -386,7 +385,7 @@ class RouterInterface(neutron.NeutronResource):
key = 'port_id'
value = self.client_plugin().resolve_port(
dict(self.properties), self.PORT, key)
self.neutron().add_interface_router(
self.client().add_interface_router(
router_id,
{key: value})
self.resource_id_set('%s:%s=%s' % (router_id, key, value))
@ -394,13 +393,12 @@ class RouterInterface(neutron.NeutronResource):
def handle_delete(self):
if not self.resource_id:
return
client = self.neutron()
tokens = self.resource_id.replace('=', ':').split(':')
if len(tokens) == 2: # compatible with old data
tokens.insert(1, 'subnet_id')
(router_id, key, value) = tokens
try:
client.remove_interface_router(
self.client().remove_interface_router(
router_id,
{key: value})
except Exception as ex:
@ -487,7 +485,7 @@ class RouterGateway(neutron.NeutronResource):
router_id = self.properties[self.ROUTER_ID]
network_id = self.client_plugin().resolve_network(
dict(self.properties), self.NETWORK, 'network_id')
self.neutron().add_gateway_router(
self.client().add_gateway_router(
router_id,
{'network_id': network_id})
self.resource_id_set('%s:%s' % (router_id, network_id))
@ -495,10 +493,10 @@ class RouterGateway(neutron.NeutronResource):
def handle_delete(self):
if not self.resource_id:
return
client = self.neutron()
(router_id, network_id) = self.resource_id.split(':')
try:
client.remove_gateway_router(router_id)
self.client().remove_gateway_router(router_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)

12
heat/engine/resources/openstack/neutron/security_group.py
View File

@ -153,7 +153,7 @@ class SecurityGroup(neutron.NeutronResource):
self.physical_resource_name())
rules = props.pop(self.RULES, [])
sec = self.neutron().create_security_group(
sec = self.client().create_security_group(
{'security_group': props})['security_group']
self.resource_id_set(sec['id'])
@ -198,7 +198,7 @@ class SecurityGroup(neutron.NeutronResource):
rule = self._format_rule(i)
try:
self.neutron().create_security_group_rule(
self.client().create_security_group_rule(
{'security_group_rule': rule})
except Exception as ex:
if not self.client_plugin().is_conflict(ex):
@ -206,7 +206,7 @@ class SecurityGroup(neutron.NeutronResource):
def _delete_rules(self, to_delete=None):
try:
sec = self.neutron().show_security_group(
sec = self.client().show_security_group(
self.resource_id)['security_group']
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
@ -214,7 +214,7 @@ class SecurityGroup(neutron.NeutronResource):
for rule in sec['security_group_rules']:
if to_delete is None or to_delete(rule):
try:
self.neutron().delete_security_group_rule(rule['id'])
self.client().delete_security_group_rule(rule['id'])
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
@ -225,7 +225,7 @@ class SecurityGroup(neutron.NeutronResource):
self._delete_rules()
try:
self.neutron().delete_security_group(self.resource_id)
self.client().delete_security_group(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
@ -233,7 +233,7 @@ class SecurityGroup(neutron.NeutronResource):
props = self.prepare_update_properties(json_snippet)
rules = props.pop(self.RULES, [])
self.neutron().update_security_group(
self.client().update_security_group(
self.resource_id, {'security_group': props})
# handle rules changes by:

9
heat/engine/resources/openstack/neutron/subnet.py
View File

@ -295,24 +295,23 @@ class Subnet(neutron.NeutronResource):
self.client_plugin().resolve_network(props, self.NETWORK, 'network_id')
self._null_gateway_ip(props)
subnet = self.neutron().create_subnet({'subnet': props})['subnet']
subnet = self.client().create_subnet({'subnet': props})['subnet']
self.resource_id_set(subnet['id'])
def handle_delete(self):
client = self.neutron()
try:
client.delete_subnet(self.resource_id)
self.client().delete_subnet(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
return True
def _show_resource(self):
return self.neutron().show_subnet(self.resource_id)['subnet']
return self.client().show_subnet(self.resource_id)['subnet']
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
props = self.prepare_update_properties(json_snippet)
self.neutron().update_subnet(
self.client().update_subnet(
self.resource_id, {'subnet': props})

42
heat/engine/resources/openstack/neutron/vpnservice.py
View File

@ -147,7 +147,7 @@ class VPNService(neutron.NeutronResource):
]
def _show_resource(self):
return self.neutron().show_vpnservice(self.resource_id)['vpnservice']
return self.client().show_vpnservice(self.resource_id)['vpnservice']
def validate(self):
super(VPNService, self).validate()
@ -162,19 +162,18 @@ class VPNService(neutron.NeutronResource):
self.physical_resource_name())
self.client_plugin().resolve_subnet(props, self.SUBNET, 'subnet_id')
self.client_plugin().resolve_router(props, self.ROUTER, 'router_id')
vpnservice = self.neutron().create_vpnservice({'vpnservice': props})[
vpnservice = self.client().create_vpnservice({'vpnservice': props})[
'vpnservice']
self.resource_id_set(vpnservice['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_vpnservice(self.resource_id,
{'vpnservice': prop_diff})
self.client().update_vpnservice(self.resource_id,
{'vpnservice': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_vpnservice(self.resource_id)
self.client().delete_vpnservice(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -400,26 +399,25 @@ class IPsecSiteConnection(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_ipsec_site_connection(self.resource_id)[
return self.client().show_ipsec_site_connection(self.resource_id)[
'ipsec_site_connection']
def handle_create(self):
props = self.prepare_properties(
self.properties,
self.physical_resource_name())
ipsec_site_connection = self.neutron().create_ipsec_site_connection(
ipsec_site_connection = self.client().create_ipsec_site_connection(
{'ipsec_site_connection': props})['ipsec_site_connection']
self.resource_id_set(ipsec_site_connection['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_ipsec_site_connection(
self.client().update_ipsec_site_connection(
self.resource_id, {'ipsec_site_connection': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_ipsec_site_connection(self.resource_id)
self.client().delete_ipsec_site_connection(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -570,25 +568,24 @@ class IKEPolicy(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_ikepolicy(self.resource_id)['ikepolicy']
return self.client().show_ikepolicy(self.resource_id)['ikepolicy']
def handle_create(self):
props = self.prepare_properties(
self.properties,
self.physical_resource_name())
ikepolicy = self.neutron().create_ikepolicy({'ikepolicy': props})[
ikepolicy = self.client().create_ikepolicy({'ikepolicy': props})[
'ikepolicy']
self.resource_id_set(ikepolicy['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_ikepolicy(self.resource_id,
{'ikepolicy': prop_diff})
self.client().update_ikepolicy(self.resource_id,
{'ikepolicy': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_ikepolicy(self.resource_id)
self.client().delete_ikepolicy(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:
@ -741,25 +738,24 @@ class IPsecPolicy(neutron.NeutronResource):
}
def _show_resource(self):
return self.neutron().show_ipsecpolicy(self.resource_id)['ipsecpolicy']
return self.client().show_ipsecpolicy(self.resource_id)['ipsecpolicy']
def handle_create(self):
props = self.prepare_properties(
self.properties,
self.physical_resource_name())
ipsecpolicy = self.neutron().create_ipsecpolicy(
ipsecpolicy = self.client().create_ipsecpolicy(
{'ipsecpolicy': props})['ipsecpolicy']
self.resource_id_set(ipsecpolicy['id'])
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
self.neutron().update_ipsecpolicy(self.resource_id,
{'ipsecpolicy': prop_diff})
self.client().update_ipsecpolicy(self.resource_id,
{'ipsecpolicy': prop_diff})
def handle_delete(self):
client = self.neutron()
try:
client.delete_ipsecpolicy(self.resource_id)
self.client().delete_ipsecpolicy(self.resource_id)
except Exception as ex:
self.client_plugin().ignore_not_found(ex)
else:

4
heat/tests/aws/test_instance_network.py
View File

@ -275,8 +275,8 @@ class instancesTest(common.HeatTestCase):
self._mock_get_image_id_success(image_id, 1)
self.stub_SubnetConstraint_validate()
self.m.StubOutWithMock(nic, 'neutron')
nic.neutron().MultipleTimes().AndReturn(FakeNeutron())
self.m.StubOutWithMock(nic, 'client')
nic.client().AndReturn(FakeNeutron())
self.m.StubOutWithMock(neutron.NeutronClientPlugin, '_create')
neutron.NeutronClientPlugin._create().MultipleTimes().AndReturn(