Rename instance_id to resource_id.

The current naming gets increasingly inaccurate with every new resource ;)

Change-Id: I98629c7f8fd9c391f58c16ae1f6f2a7a232a2802

diff --git a/heat/engine/api.py b/heat/engine/api.py
index 15e8c8a893da13a7f7335fa9a490474d039f9ba4..2c04db392fa28c4a912be092b8849d2ceb5f28df 100644 (file)
--- a/heat/engine/api.py
+++ b/heat/engine/api.py
@@ -134,7 +134,7 @@ def format_stack_resource(resource):
         RES_DESCRIPTION: resource.parsed_template().get('Description', ''),
         RES_UPDATED_TIME: timeutils.isotime(last_updated_time),
         RES_NAME: resource.name,
-        RES_PHYSICAL_ID: resource.instance_id or '',
+        RES_PHYSICAL_ID: resource.resource_id or '',
         RES_METADATA: resource.metadata,
         RES_STATUS: resource.state,
         RES_STATUS_DATA: resource.state_description,

diff --git a/heat/engine/resources/autoscaling.py b/heat/engine/resources/autoscaling.py
index 40c79189da15a9b68fc8ff0c7f86210030e428c9..a784de877d29eeabb7ad6e7a54e2fdd775c63d7b 100644 (file)
--- a/heat/engine/resources/autoscaling.py
+++ b/heat/engine/resources/autoscaling.py
@@ -49,7 +49,7 @@ class AutoScalingGroup(resource.Resource):
 
     def __init__(self, name, json_snippet, stack):
         super(AutoScalingGroup, self).__init__(name, json_snippet, stack)
-        # instance_id is a list of resources
+        # resource_id is a list of resources
 
     def handle_create(self):
 
@@ -65,9 +65,9 @@ class AutoScalingGroup(resource.Resource):
         return self.UPDATE_REPLACE
 
     def handle_delete(self):
-        if self.instance_id is not None:
+        if self.resource_id is not None:
             conf = self.properties['LaunchConfigurationName']
-            inst_list = self.instance_id.split(',')
+            inst_list = self.resource_id.split(',')
             logger.debug('handle_delete %s' % str(inst_list))
             for victim in inst_list:
                 logger.debug('handle_delete %s' % victim)
@@ -78,8 +78,8 @@ class AutoScalingGroup(resource.Resource):
 
     def adjust(self, adjustment, adjustment_type='ChangeInCapacity'):
         inst_list = []
-        if self.instance_id is not None:
-            inst_list = sorted(self.instance_id.split(','))
+        if self.resource_id is not None:
+            inst_list = sorted(self.resource_id.split(','))
 
         capacity = len(inst_list)
         if adjustment_type == 'ChangeInCapacity':
@@ -112,7 +112,7 @@ class AutoScalingGroup(resource.Resource):
                                          self.stack.t['Resources'][conf],
                                          self.stack)
                 inst_list.append(name)
-                self.instance_id_set(','.join(inst_list))
+                self.resource_id_set(','.join(inst_list))
                 inst.create()
         else:
             # shrink (kill largest numbered first)
@@ -123,7 +123,7 @@ class AutoScalingGroup(resource.Resource):
                                          self.stack)
                 inst.destroy()
                 inst_list.remove(victim)
-                self.instance_id_set(','.join(inst_list))
+                self.resource_id_set(','.join(inst_list))
 
         # notify the LoadBalancer to reload it's config to include
         # the changes in instances we have just made.

diff --git a/heat/engine/resources/eip.py b/heat/engine/resources/eip.py
index 0990ee63fd55c9795495f247de6fc2b763f2e100..b1514527434d6cbb87753f391999bfb0447253fd 100644 (file)
--- a/heat/engine/resources/eip.py
+++ b/heat/engine/resources/eip.py
@@ -33,9 +33,9 @@ class ElasticIp(resource.Resource):
 
     def _ipaddress(self):
         if self.ipaddress is None:
-            if self.instance_id is not None:
+            if self.resource_id is not None:
                 try:
-                    ips = self.nova().floating_ips.get(self.instance_id)
+                    ips = self.nova().floating_ips.get(self.resource_id)
                 except NotFound as ex:
                     logger.warn("Floating IPs not found: %s" % str(ex))
                 else:
@@ -47,22 +47,22 @@ class ElasticIp(resource.Resource):
         ips = self.nova().floating_ips.create()
         logger.info('ElasticIp create %s' % str(ips))
         self.ipaddress = ips.ip
-        self.instance_id_set(ips.id)
+        self.resource_id_set(ips.id)
 
     def handle_update(self):
         return self.UPDATE_REPLACE
 
     def handle_delete(self):
         """De-allocate a floating IP."""
-        if self.instance_id is not None:
-            self.nova().floating_ips.delete(self.instance_id)
+        if self.resource_id is not None:
+            self.nova().floating_ips.delete(self.resource_id)
 
     def FnGetRefId(self):
         return unicode(self._ipaddress())
 
     def FnGetAtt(self, key):
         if key == 'AllocationId':
-            return unicode(self.instance_id)
+            return unicode(self.resource_id)
         else:
             raise exception.InvalidTemplateAttribute(resource=self.name,
                                                      key=key)
@@ -89,7 +89,7 @@ class ElasticIpAssociation(resource.Resource):
 
         server = self.nova().servers.get(self.properties['InstanceId'])
         server.add_floating_ip(self.properties['EIP'])
-        self.instance_id_set(self.properties['EIP'])
+        self.resource_id_set(self.properties['EIP'])
 
     def handle_delete(self):
         """Remove a floating IP address from a server."""

diff --git a/heat/engine/resources/instance.py b/heat/engine/resources/instance.py
index 6f9f2264dad3cf9b77c72f573b654ef57bd1a48f..2f2422e6d185dc2c8e4d34fd1e045e11bab4d2eb 100644 (file)
--- a/heat/engine/resources/instance.py
+++ b/heat/engine/resources/instance.py
@@ -36,13 +36,13 @@ class Restarter(resource.Resource):
     properties_schema = {'InstanceId': {'Type': 'String',
                                         'Required': True}}
 
-    def _find_resource(self, instance_id):
+    def _find_resource(self, resource_id):
         '''
         Return the resource with the specified instance ID, or None if it
         cannot be found.
         '''
         for resource in self.stack:
-            if resource.instance_id == instance_id:
+            if resource.resource_id == resource_id:
                 return resource
         return None
 
@@ -128,7 +128,7 @@ class Instance(resource.Resource):
         '''
         if self.ipaddress is None:
             try:
-                server = self.nova().servers.get(self.instance_id)
+                server = self.nova().servers.get(self.resource_id)
             except NotFound as ex:
                 logger.warn('Instance IP address not found (%s)' % str(ex))
             else:
@@ -250,7 +250,7 @@ class Instance(resource.Resource):
             server.get()
             eventlet.sleep(1)
         if server.status == 'ACTIVE':
-            self.instance_id_set(server.id)
+            self.resource_id_set(server.id)
             self._set_ipaddress(server.networks)
         else:
             raise exception.Error('%s instance[%s] status[%s]' %
@@ -286,10 +286,10 @@ class Instance(resource.Resource):
         '''
         Delete an instance, blocking until it is disposed by OpenStack
         '''
-        if self.instance_id is None:
+        if self.resource_id is None:
             return
         try:
-            server = self.nova().servers.get(self.instance_id)
+            server = self.nova().servers.get(self.resource_id)
         except NotFound:
             pass
         else:
@@ -300,4 +300,4 @@ class Instance(resource.Resource):
                 except NotFound:
                     break
                 eventlet.sleep(0.2)
-        self.instance_id = None
+        self.resource_id = None

diff --git a/heat/engine/resources/quantum/floatingip.py b/heat/engine/resources/quantum/floatingip.py
index 92d54345d3194b82eb92e3d724196f8a18b8db7d..4f8a70b192b3e3c8ee576f0b80806c1a180902d5 100644 (file)
--- a/heat/engine/resources/quantum/floatingip.py
+++ b/heat/engine/resources/quantum/floatingip.py
@@ -32,18 +32,18 @@ class FloatingIP(quantum.QuantumResource):
         props = self.prepare_properties(self.properties, self.name)
         fip = self.quantum().create_floatingip({
             'floatingip': props})['floatingip']
-        self.instance_id_set(fip['id'])
+        self.resource_id_set(fip['id'])
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            client.delete_floatingip(self.instance_id)
+            client.delete_floatingip(self.resource_id)
         except:
             pass
 
     def FnGetAtt(self, key):
         attributes = self.quantum().show_floatingip(
-            self.instance_id)['floatingip']
+            self.resource_id)['floatingip']
         return self.handle_get_attributes(self.name, key, attributes)
 
 
@@ -65,12 +65,12 @@ class FloatingIPAssociation(quantum.QuantumResource):
 
         self.quantum().update_floatingip(floatingip_id, {
             'floatingip': props})['floatingip']
-        self.instance_id_set('%s:%s' % (floatingip_id, props['port_id']))
+        self.resource_id_set('%s:%s' % (floatingip_id, props['port_id']))
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            (floatingip_id, port_id) = self.instance_id.split(':')
+            (floatingip_id, port_id) = self.resource_id.split(':')
             client.update_floatingip(floatingip_id,
                 {'floatingip': {'port_id': None}})
         except:

diff --git a/heat/engine/resources/quantum/net.py b/heat/engine/resources/quantum/net.py
index 352e92212ef1d31ed118d7f4c2ef62e29eae0abb..02be17ad3c7beccd08811b54e2aa7b44c049292a 100644 (file)
--- a/heat/engine/resources/quantum/net.py
+++ b/heat/engine/resources/quantum/net.py
@@ -33,16 +33,16 @@ class Net(quantum.QuantumResource):
     def handle_create(self):
         props = self.prepare_properties(self.properties, self.name)
         net = self.quantum().create_network({'network': props})['network']
-        self.instance_id_set(net['id'])
+        self.resource_id_set(net['id'])
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            client.delete_network(self.instance_id)
+            client.delete_network(self.resource_id)
         except:
             pass
 
     def FnGetAtt(self, key):
         attributes = self.quantum().show_network(
-            self.instance_id)['network']
+            self.resource_id)['network']
         return self.handle_get_attributes(self.name, key, attributes)

diff --git a/heat/engine/resources/quantum/port.py b/heat/engine/resources/quantum/port.py
index ccdf31bdc5bd92b49bd2c581b072ed75cb71e063..b76f699bf668f5c1352598974df9326533b2fa1a 100644 (file)
--- a/heat/engine/resources/quantum/port.py
+++ b/heat/engine/resources/quantum/port.py
@@ -46,16 +46,16 @@ class Port(quantum.QuantumResource):
     def handle_create(self):
         props = self.prepare_properties(self.properties, self.name)
         port = self.quantum().create_port({'port': props})['port']
-        self.instance_id_set(port['id'])
+        self.resource_id_set(port['id'])
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            client.delete_port(self.instance_id)
+            client.delete_port(self.resource_id)
         except:
             pass
 
     def FnGetAtt(self, key):
         attributes = self.quantum().show_port(
-            self.instance_id)['port']
+            self.resource_id)['port']
         return self.handle_get_attributes(self.name, key, attributes)

diff --git a/heat/engine/resources/quantum/quantum.py b/heat/engine/resources/quantum/quantum.py
index 30e3df4c66cdecb191e1f2b0e7c13e879d9431d6..6c3cf926c5959c86fb241fc760e2d4d9de0a69eb 100644 (file)
--- a/heat/engine/resources/quantum/quantum.py
+++ b/heat/engine/resources/quantum/quantum.py
@@ -89,4 +89,4 @@ class QuantumResource(resource.Resource):
         return self.UPDATE_REPLACE
 
     def FnGetRefId(self):
-        return unicode(self.instance_id)
+        return unicode(self.resource_id)

diff --git a/heat/engine/resources/quantum/router.py b/heat/engine/resources/quantum/router.py
index 852a864ebcceef4de11e75ac41a9f0a58ca51e34..9a13924dc83f4ad78035a35b5985ff728ecd6e2d 100644 (file)
--- a/heat/engine/resources/quantum/router.py
+++ b/heat/engine/resources/quantum/router.py
@@ -34,18 +34,18 @@ class Router(quantum.QuantumResource):
     def handle_create(self):
         props = self.prepare_properties(self.properties, self.name)
         router = self.quantum().create_router({'router': props})['router']
-        self.instance_id_set(router['id'])
+        self.resource_id_set(router['id'])
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            client.delete_router(self.instance_id)
+            client.delete_router(self.resource_id)
         except:
             pass
 
     def FnGetAtt(self, key):
         attributes = self.quantum().show_router(
-            self.instance_id)['router']
+            self.resource_id)['router']
         return self.handle_get_attributes(self.name, key, attributes)
 
 
@@ -64,12 +64,12 @@ class RouterInterface(quantum.QuantumResource):
         subnet_id = self.properties.get('subnet_id')
         self.quantum().add_interface_router(router_id,
             {'subnet_id': subnet_id})
-        self.instance_id_set('%s:%s' % (router_id, subnet_id))
+        self.resource_id_set('%s:%s' % (router_id, subnet_id))
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            (router_id, subnet_id) = self.instance_id.split(':')
+            (router_id, subnet_id) = self.resource_id.split(':')
             client.remove_interface_router(router_id,
                 {'subnet_id': subnet_id})
         except:
@@ -91,12 +91,12 @@ class RouterGateway(quantum.QuantumResource):
         network_id = self.properties.get('network_id')
         self.quantum().add_gateway_router(router_id,
             {'network_id': network_id})
-        self.instance_id_set('%s:%s' % (router_id, network_id))
+        self.resource_id_set('%s:%s' % (router_id, network_id))
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            (router_id, network_id) = self.instance_id.split(':')
+            (router_id, network_id) = self.resource_id.split(':')
             client.remove_gateway_router(router_id)
         except:
             pass

diff --git a/heat/engine/resources/quantum/subnet.py b/heat/engine/resources/quantum/subnet.py
index 1334903e90c978e22d70b605f07bd8cec7b93502..3c0c13e9424a69d3b8f9d70e77810c5f28e3d6ff 100644 (file)
--- a/heat/engine/resources/quantum/subnet.py
+++ b/heat/engine/resources/quantum/subnet.py
@@ -54,16 +54,16 @@ class Subnet(quantum.QuantumResource):
     def handle_create(self):
         props = self.prepare_properties(self.properties, self.name)
         subnet = self.quantum().create_subnet({'subnet': props})['subnet']
-        self.instance_id_set(subnet['id'])
+        self.resource_id_set(subnet['id'])
 
     def handle_delete(self):
         client = self.quantum()
         try:
-            client.delete_subnet(self.instance_id)
+            client.delete_subnet(self.resource_id)
         except:
             pass
 
     def FnGetAtt(self, key):
         attributes = self.quantum().show_subnet(
-            self.instance_id)['subnet']
+            self.resource_id)['subnet']
         return self.handle_get_attributes(self.name, key, attributes)

diff --git a/heat/engine/resources/resource.py b/heat/engine/resources/resource.py
index a605a13376830c988ea2f00f5c6543851f6b52bd..7a3411669e9807467e5260c61d47a60f47f34098 100644 (file)
--- a/heat/engine/resources/resource.py
+++ b/heat/engine/resources/resource.py
@@ -104,12 +104,12 @@ class Resource(object):
         resource = db_api.resource_get_by_name_and_stack(self.context,
                                                          name, stack.id)
         if resource:
-            self.instance_id = resource.nova_instance
+            self.resource_id = resource.nova_instance
             self.state = resource.state
             self.state_description = resource.state_description
             self.id = resource.id
         else:
-            self.instance_id = None
+            self.resource_id = None
             self.state = None
             self.state_description = ''
             self.id = None
@@ -255,7 +255,7 @@ class Resource(object):
             return 'Resource deletion already in progress'
 
         logger.info('deleting %s (inst:%s db_id:%s)' %
-                    (str(self), self.instance_id, str(self.id)))
+                    (str(self), self.resource_id, str(self.id)))
         self.state_set(self.DELETE_IN_PROGRESS)
 
         try:
@@ -291,12 +291,12 @@ class Resource(object):
 
         self.id = None
 
-    def instance_id_set(self, inst):
-        self.instance_id = inst
+    def resource_id_set(self, inst):
+        self.resource_id = inst
         if self.id is not None:
             try:
                 rs = db_api.resource_get(self.stack.context, self.id)
-                rs.update_and_save({'nova_instance': self.instance_id})
+                rs.update_and_save({'nova_instance': self.resource_id})
             except Exception as ex:
                 logger.warn('db error %s' % str(ex))
 
@@ -305,7 +305,7 @@ class Resource(object):
         try:
             rs = {'state': self.state,
                   'stack_id': self.stack.id,
-                  'nova_instance': self.instance_id,
+                  'nova_instance': self.resource_id,
                   'name': self.name,
                   'rsrc_metadata': self.metadata,
                   'stack_name': self.stack.name}
@@ -321,7 +321,7 @@ class Resource(object):
     def _add_event(self, new_state, reason):
         '''Add a state change event to the database'''
         ev = {'logical_resource_id': self.name,
-              'physical_resource_id': self.instance_id,
+              'physical_resource_id': self.resource_id,
               'stack_id': self.stack.id,
               'stack_name': self.stack.name,
               'resource_status': new_state,
@@ -343,7 +343,7 @@ class Resource(object):
                 rs = db_api.resource_get(self.context, self.id)
                 rs.update_and_save({'state': self.state,
                                     'state_description': reason,
-                                    'nova_instance': self.instance_id})
+                                    'nova_instance': self.resource_id})
 
                 self.stack.updated_time = datetime.utcnow()
             except Exception as ex:
@@ -363,8 +363,8 @@ class Resource(object):
         http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/\
         intrinsic-function-reference-ref.html
         '''
-        if self.instance_id is not None:
-            return unicode(self.instance_id)
+        if self.resource_id is not None:
+            return unicode(self.resource_id)
         else:
             return unicode(self.name)
 

diff --git a/heat/engine/resources/s3.py b/heat/engine/resources/s3.py
index 5daa71bf9af995c74fe2fba05bd5d8146fbdf0f3..dcf6b82a5a3804d5f9dd2e9b911f3989551b4f9b 100644 (file)
--- a/heat/engine/resources/s3.py
+++ b/heat/engine/resources/s3.py
@@ -94,7 +94,7 @@ class S3Bucket(resource.Resource):
             headers['X-Container-Write'] = tenant_username
 
         self.swift().put_container(container, headers)
-        self.instance_id_set(container)
+        self.resource_id_set(container)
 
     def handle_update(self):
         return self.UPDATE_REPLACE
@@ -103,15 +103,15 @@ class S3Bucket(resource.Resource):
         """Perform specified delete policy"""
         if self.properties['DeletionPolicy'] == 'Retain':
             return
-        logger.debug('S3Bucket delete container %s' % self.instance_id)
-        if self.instance_id is not None:
+        logger.debug('S3Bucket delete container %s' % self.resource_id)
+        if self.resource_id is not None:
             try:
-                self.swift().delete_container(self.instance_id)
+                self.swift().delete_container(self.resource_id)
             except ClientException as ex:
                 logger.warn("Delete container failed: %s" % str(ex))
 
     def FnGetRefId(self):
-        return unicode(self.instance_id)
+        return unicode(self.resource_id)
 
     def FnGetAtt(self, key):
         url, token_id = self.swift().get_auth()
@@ -120,7 +120,7 @@ class S3Bucket(resource.Resource):
             return parsed[1].split(':')[0]
         elif key == 'WebsiteURL':
             return '%s://%s%s/%s' % (parsed[0], parsed[1], parsed[2],
-                                      self.instance_id)
+                                      self.resource_id)
         else:
             raise exception.InvalidTemplateAttribute(resource=self.name,
                                                      key=key)

diff --git a/heat/engine/resources/security_group.py b/heat/engine/resources/security_group.py
index 970cd08b0a255c04ea116b4099162abe132cb47a..d304eb0d16f3f57dc9f83699ed2b6b212d12483b 100644 (file)
--- a/heat/engine/resources/security_group.py
+++ b/heat/engine/resources/security_group.py
@@ -49,7 +49,7 @@ class SecurityGroup(resource.Resource):
                                           self.physical_resource_name(),
                                           self.properties['GroupDescription'])
 
-        self.instance_id_set(sec.id)
+        self.resource_id_set(sec.id)
         if self.properties['SecurityGroupIngress']:
             rules_client = self.nova().security_group_rules
             for i in self.properties['SecurityGroupIngress']:
@@ -71,9 +71,9 @@ class SecurityGroup(resource.Resource):
         return self.UPDATE_REPLACE
 
     def handle_delete(self):
-        if self.instance_id is not None:
+        if self.resource_id is not None:
             try:
-                sec = self.nova().security_groups.get(self.instance_id)
+                sec = self.nova().security_groups.get(self.resource_id)
             except NotFound:
                 pass
             else:
@@ -84,7 +84,7 @@ class SecurityGroup(resource.Resource):
                         pass
 
                 self.nova().security_groups.delete(sec)
-            self.instance_id = None
+            self.resource_id = None
 
     def FnGetRefId(self):
         return unicode(self.name)

diff --git a/heat/engine/resources/stack.py b/heat/engine/resources/stack.py
index 40614d283fc34ba9580298685f9c95d58a565c5b..a729b37b979bc4f0fae8b5c7dbbcdb784dedd672 100644 (file)
--- a/heat/engine/resources/stack.py
+++ b/heat/engine/resources/stack.py
@@ -46,9 +46,9 @@ class Stack(resource.Resource):
         return p
 
     def nested(self):
-        if self._nested is None and self.instance_id is not None:
+        if self._nested is None and self.resource_id is not None:
             self._nested = parser.Stack.load(self.context,
-                                             self.instance_id)
+                                             self.resource_id)
 
             if self._nested is None:
                 raise exception.NotFound('Nested stack not found in DB')
@@ -69,7 +69,7 @@ class Stack(resource.Resource):
                                     params)
 
         nested_id = self._nested.store(self.stack)
-        self.instance_id_set(nested_id)
+        self.resource_id_set(nested_id)
         self._nested.create()
         if self._nested.state != self._nested.CREATE_COMPLETE:
             raise exception.Error(self._nested.state_description)

diff --git a/heat/engine/resources/user.py b/heat/engine/resources/user.py
index 16a6ac102778b7d0cb4af148f4eee248f9993915..43014ac102265696fe07c355502e75ddbd802bca 100644 (file)
--- a/heat/engine/resources/user.py
+++ b/heat/engine/resources/user.py
@@ -62,7 +62,7 @@ class User(resource.Resource):
                                             self.physical_resource_name(),
                                             tenant_id=tenant_id,
                                             enabled=True)
-        self.instance_id_set(user.id)
+        self.resource_id_set(user.id)
 
         # We add the new user to a special keystone role
         # This role is designed to allow easier differentiation of the
@@ -84,13 +84,13 @@ class User(resource.Resource):
         return self.UPDATE_REPLACE
 
     def handle_delete(self):
-        if self.instance_id is None:
+        if self.resource_id is None:
             return
         try:
-            user = self.keystone().users.get(DummyId(self.instance_id))
+            user = self.keystone().users.get(DummyId(self.resource_id))
         except Exception as ex:
             logger.info('user %s/%s does not exist' %
-                        (self.physical_resource_name(), self.instance_id))
+                        (self.physical_resource_name(), self.resource_id))
             return
 
         # tempory hack to work around an openstack bug.
@@ -158,7 +158,7 @@ class AccessKey(resource.Resource):
 
         tenant_id = self.context.tenant_id
         cred = self.keystone().ec2.create(user.id, tenant_id)
-        self.instance_id_set(cred.access)
+        self.resource_id_set(cred.access)
         self._secret = cred.secret
 
     def handle_update(self):
@@ -166,8 +166,8 @@ class AccessKey(resource.Resource):
 
     def handle_delete(self):
         user = self._user_from_name(self.properties['UserName'])
-        if user and self.instance_id:
-            self.keystone().ec2.delete(user.id, self.instance_id)
+        if user and self.resource_id:
+            self.keystone().ec2.delete(user.id, self.resource_id)
 
     def _secret_accesskey(self):
         '''
@@ -186,9 +186,9 @@ class AccessKey(resource.Resource):
                 # This will allow "instance users" to retrieve resource
                 # metadata but not manipulate user resources in any other way
                 user_id = self.keystone().auth_user_id
-                cred = self.keystone().ec2.get(user_id, self.instance_id)
+                cred = self.keystone().ec2.get(user_id, self.resource_id)
                 self._secret = cred.secret
-                self.instance_id_set(cred.access)
+                self.resource_id_set(cred.access)
             except Exception as ex:
                 logger.warn('could not get secret for %s Error:%s' %
                             (self.properties['UserName'],

diff --git a/heat/engine/resources/volume.py b/heat/engine/resources/volume.py
index 090daf2e6648cb353548f6b89310d5a643f0260b..d4f9c98a2469d1e2cf43e917cdd34dad3611a735 100644 (file)
--- a/heat/engine/resources/volume.py
+++ b/heat/engine/resources/volume.py
@@ -42,7 +42,7 @@ class Volume(resource.Resource):
             eventlet.sleep(1)
             vol.get()
         if vol.status == 'available':
-            self.instance_id_set(vol.id)
+            self.resource_id_set(vol.id)
         else:
             raise exception.Error(vol.status)
 
@@ -50,13 +50,13 @@ class Volume(resource.Resource):
         return self.UPDATE_REPLACE
 
     def handle_delete(self):
-        if self.instance_id is not None:
-            vol = self.nova('volume').volumes.get(self.instance_id)
+        if self.resource_id is not None:
+            vol = self.nova('volume').volumes.get(self.resource_id)
             if vol.status == 'in-use':
                 logger.warn('cant delete volume when in-use')
                 raise exception.Error("Volume in use")
 
-            self.nova('volume').volumes.delete(self.instance_id)
+            self.nova('volume').volumes.delete(self.resource_id)
 
 
 class VolumeAttachment(resource.Resource):
@@ -86,7 +86,7 @@ class VolumeAttachment(resource.Resource):
             eventlet.sleep(1)
             vol.get()
         if vol.status == 'in-use':
-            self.instance_id_set(va.id)
+            self.resource_id_set(va.id)
         else:
             raise exception.Error(vol.status)
 

diff --git a/heat/engine/resources/wait_condition.py b/heat/engine/resources/wait_condition.py
index 74d5c7dc00255fdd6a34ff18c5d78ae8f78751b3..d00dac995bfe51418d9164a0b6a38905cba9fd9a 100644 (file)
--- a/heat/engine/resources/wait_condition.py
+++ b/heat/engine/resources/wait_condition.py
@@ -39,7 +39,7 @@ class WaitConditionHandle(resource.Resource):
         super(WaitConditionHandle, self).__init__(name, json_snippet, stack)
 
     def handle_create(self):
-        self.instance_id = '%s/stacks/%s/resources/%s' % \
+        self.resource_id = '%s/stacks/%s/resources/%s' % \
                            (cfg.CONF.heat_waitcondition_server_url,
                             self.stack.id,
                             self.name)

diff --git a/heat/tests/functional/test_WordPress_Single_Instance_With_EBS_EIP.py b/heat/tests/functional/test_WordPress_Single_Instance_With_EBS_EIP.py
index 2102019d2fd81c42bc4f9eb3601363aa22ceef00..9964927ffc608298e839489ef1346f4a89689086 100644 (file)
--- a/heat/tests/functional/test_WordPress_Single_Instance_With_EBS_EIP.py
+++ b/heat/tests/functional/test_WordPress_Single_Instance_With_EBS_EIP.py
@@ -57,7 +57,7 @@ class WordPressEBSEIPFunctionalTest(unittest.TestCase):
             found = 0
             mylist = self.stack.novaclient.floating_ips.list()
             for item in mylist:
-                if item.instance_id == self.stack.instance_phys_ids()[0]:
+                if item.resource_id == self.stack.instance_phys_ids()[0]:
                     print 'floating IP found', item.ip
                     found = 1
                     break

diff --git a/heat/tests/functional/test_WordPress_Single_Instance_With_EIP.py b/heat/tests/functional/test_WordPress_Single_Instance_With_EIP.py
index da70be9d3cd844378657689c02de5608c21fe0ba..3902a78e65e0b28b82af5e0552ebc9907e6adca9 100644 (file)
--- a/heat/tests/functional/test_WordPress_Single_Instance_With_EIP.py
+++ b/heat/tests/functional/test_WordPress_Single_Instance_With_EIP.py
@@ -57,7 +57,7 @@ class WordPressEIPFunctionalTest(unittest.TestCase):
             found = 0
             mylist = self.stack.novaclient.floating_ips.list()
             for item in mylist:
-                if item.instance_id == self.stack.instance_phys_ids()[0]:
+                if item.resource_id == self.stack.instance_phys_ids()[0]:
                     print 'floating IP found', item.ip
                     found = 1
                     break

diff --git a/heat/tests/test_autoscaling.py b/heat/tests/test_autoscaling.py
index d8410660e5700bd5c50e5d361f29b5720b52c3bc..f87170b1ff5a6ec14c2380a8d8d1bf6e715d443a 100644 (file)
--- a/heat/tests/test_autoscaling.py
+++ b/heat/tests/test_autoscaling.py
@@ -88,7 +88,7 @@ class AutoScalingTest(unittest.TestCase):
         resource = self.create_scaling_group(t, stack, 'WebServerGroup')
 
         self.assertEqual('WebServerGroup', resource.FnGetRefId())
-        self.assertEqual('WebServerGroup-0', resource.instance_id)
+        self.assertEqual('WebServerGroup-0', resource.resource_id)
         self.assertEqual(asc.AutoScalingGroup.UPDATE_REPLACE,
                   resource.handle_update())
 
@@ -99,46 +99,46 @@ class AutoScalingTest(unittest.TestCase):
         properties['DesiredCapacity'] = '3'
         resource = self.create_scaling_group(t, stack, 'WebServerGroup')
         self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # reduce to 1
         resource.adjust(-2)
-        self.assertEqual('WebServerGroup-0', resource.instance_id)
+        self.assertEqual('WebServerGroup-0', resource.resource_id)
 
         # raise to 3
         resource.adjust(2)
         self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # set to 2
         resource.adjust(2, 'ExactCapacity')
         self.assertEqual('WebServerGroup-0,WebServerGroup-1',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # raise above the max
         resource.adjust(2)
         self.assertEqual('WebServerGroup-0,WebServerGroup-1',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # lower below the min
         resource.adjust(-2)
         self.assertEqual('WebServerGroup-0,WebServerGroup-1',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # no change
         resource.adjust(0)
         self.assertEqual('WebServerGroup-0,WebServerGroup-1',
-                         resource.instance_id)
+                         resource.resource_id)
 
         # reduce by 50%
         resource.adjust(-50, 'PercentChangeInCapacity')
         self.assertEqual('WebServerGroup-0',
-                 resource.instance_id)
+                 resource.resource_id)
 
         # raise by 200%
         resource.adjust(200, 'PercentChangeInCapacity')
         self.assertEqual('WebServerGroup-0,WebServerGroup-1,WebServerGroup-2',
-                 resource.instance_id)
+                 resource.resource_id)
 
         resource.delete()
 
@@ -150,19 +150,19 @@ class AutoScalingTest(unittest.TestCase):
         resource = self.create_scaling_group(t, stack, 'WebServerGroup')
         stack.resources['WebServerGroup'] = resource
 
-        self.assertEqual('WebServerGroup-0', resource.instance_id)
+        self.assertEqual('WebServerGroup-0', resource.resource_id)
 
         up_policy = self.create_scaling_policy(t, stack,
                                                'WebServerScaleUpPolicy')
         up_policy.alarm()
         self.assertEqual('WebServerGroup-0,WebServerGroup-1',
-                 resource.instance_id)
+                 resource.resource_id)
 
         down_policy = self.create_scaling_policy(t, stack,
                                                  'WebServerScaleDownPolicy')
         down_policy.alarm()
         self.assertEqual('WebServerGroup-0',
-                 resource.instance_id)
+                 resource.resource_id)
 
         resource.delete()
 

diff --git a/heat/tests/test_engine_service.py b/heat/tests/test_engine_service.py
index 9dde968429cba39b3f00eeec58bafe08b9dd9d83..056490c22bc183b7aca1702cc665a375073c2989 100644 (file)
--- a/heat/tests/test_engine_service.py
+++ b/heat/tests/test_engine_service.py
@@ -107,7 +107,7 @@ class stackCreateTest(unittest.TestCase):
         stack.create()
 
         self.assertNotEqual(stack.resources['WebServer'], None)
-        self.assertTrue(stack.resources['WebServer'].instance_id > 0)
+        self.assertTrue(stack.resources['WebServer'].resource_id > 0)
         self.assertNotEqual(stack.resources['WebServer'].ipaddress, '0.0.0.0')
 
     def test_wordpress_single_instance_stack_delete(self):
@@ -122,7 +122,7 @@ class stackCreateTest(unittest.TestCase):
         self.assertNotEqual(db_s, None)
 
         self.assertNotEqual(stack.resources['WebServer'], None)
-        self.assertTrue(stack.resources['WebServer'].instance_id > 0)
+        self.assertTrue(stack.resources['WebServer'].resource_id > 0)
 
         stack.delete()
 

diff --git a/heat/tests/test_instance.py b/heat/tests/test_instance.py
index 1b8873837c5a388e814e9a01be460df66a18f69d..7e12eff37caf90eeafc1d39045f8509dad59e400 100644 (file)
--- a/heat/tests/test_instance.py
+++ b/heat/tests/test_instance.py
@@ -126,14 +126,14 @@ class instancesTest(unittest.TestCase):
                 meta=None).AndReturn(self.fc.servers.list()[1])
         self.m.ReplayAll()
 
-        instance.instance_id = 1234
+        instance.resource_id = 1234
         instance.create()
 
         # this makes sure the auto increment worked on instance creation
         self.assertTrue(instance.id > 0)
 
         instance.delete()
-        self.assertTrue(instance.instance_id is None)
+        self.assertTrue(instance.resource_id is None)
         self.assertEqual(instance.state, instance.DELETE_COMPLETE)
 
     # allows testing of the test directly, shown below

diff --git a/heat/tests/test_user.py b/heat/tests/test_user.py
index 2047f56245f5914fe7ee5de946d719560b6f21b6..990139a2c9e4db5a1213de70ff2d38312b434162 100644 (file)
--- a/heat/tests/test_user.py
+++ b/heat/tests/test_user.py
@@ -143,18 +143,18 @@ class UserTest(unittest.TestCase):
         stack = self.parse_stack(t)
 
         resource = self.create_user(t, stack, 'CfnUser')
-        self.assertEqual('1', resource.instance_id)
+        self.assertEqual('1', resource.resource_id)
         self.assertEqual('test_stack.CfnUser', resource.FnGetRefId())
 
         self.assertEqual('CREATE_COMPLETE', resource.state)
         self.assertEqual(user.User.UPDATE_REPLACE,
                   resource.handle_update())
 
-        resource.instance_id = None
+        resource.resource_id = None
         self.assertEqual(None, resource.delete())
         self.assertEqual('DELETE_COMPLETE', resource.state)
 
-        resource.instance_id = '1'
+        resource.resource_id = '1'
         resource.state_set('CREATE_COMPLETE')
         self.assertEqual('CREATE_COMPLETE', resource.state)
 
@@ -206,7 +206,7 @@ class UserTest(unittest.TestCase):
         self.assertEqual(user.AccessKey.UPDATE_REPLACE,
                   resource.handle_update())
         self.assertEqual('03a4967889d94a9c8f707d267c127a3d',
-                         resource.instance_id)
+                         resource.resource_id)
 
         self.assertEqual('d5fd0c08f8cc417ead0355c67c529438',
                          resource._secret)