from heat.engine import api
from heat.engine import identifier
from heat.engine import parser
-from heat.engine import resources
from heat.engine import watchrule
from heat.engine import auth
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from resource import Resource
# License for the specific language governing permissions and limitations
# under the License.
-from heat.engine import instance
-from heat.engine.resources import Resource
+from heat.engine.resources import instance
+from heat.engine.resources import resource
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.autoscaling')
-class AutoScalingGroup(Resource):
+class AutoScalingGroup(resource.Resource):
tags_schema = {'Key': {'Type': 'String',
'Required': True},
'Value': {'Type': 'String',
return unicode(self.name)
-class LaunchConfiguration(Resource):
+class LaunchConfiguration(resource.Resource):
tags_schema = {'Key': {'Type': 'String',
'Required': True},
'Value': {'Type': 'String',
super(LaunchConfiguration, self).__init__(name, json_snippet, stack)
-class ScalingPolicy(Resource):
+class ScalingPolicy(resource.Resource):
properties_schema = {
'AutoScalingGroupName': {'Type': 'String',
'Required': True},
from heat.common import exception
from heat.engine import watchrule
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from heat.db import api as db_api
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.cloud_watch')
-class CloudWatchAlarm(Resource):
+class CloudWatchAlarm(resource.Resource):
properties_schema = {'ComparisonOperator': {'Type': 'String',
'AllowedValues': ['GreaterThanOrEqualToThreshold',
'GreaterThanThreshold', 'LessThanThreshold',
strict_dependency = False
- def validate(self):
- '''
- Validate the Properties
- '''
- return Resource.validate(self)
-
def handle_create(self):
wr = watchrule.WatchRule(context=self.context, watch_name=self.name,
rule=self.parsed_template('Properties'),
import json
from heat.common import exception
-from heat.engine import stack
+from heat.engine.resources import stack
from heat.openstack.common import log as logging
# under the License.
from heat.common import exception
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from novaclient.exceptions import NotFound
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.eip')
-class ElasticIp(Resource):
+class ElasticIp(resource.Resource):
properties_schema = {'Domain': {'Type': 'String',
'Implemented': False},
'InstanceId': {'Type': 'String'}}
def handle_update(self):
return self.UPDATE_REPLACE
- def validate(self):
- '''
- Validate the ip address here
- '''
- return Resource.validate(self)
-
def handle_delete(self):
"""De-allocate a floating IP."""
if self.instance_id is not None:
key=key)
-class ElasticIpAssociation(Resource):
+class ElasticIpAssociation(resource.Resource):
properties_schema = {'InstanceId': {'Type': 'String',
'Required': True},
'EIP': {'Type': 'String'},
def FnGetRefId(self):
return unicode(self.properties.get('EIP', '0.0.0.0'))
- def validate(self):
- '''
- Validate the ip address here
- '''
- return Resource.validate(self)
-
def handle_create(self):
"""Add a floating IP address to a server."""
logger.debug('ElasticIpAssociation %s.add_floating_ip(%s)' %
from novaclient.exceptions import NotFound
import heat
-from heat.engine import resources
+from heat.engine.resources import resource
from heat.common import exception
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.instance')
-class Restarter(resources.Resource):
+class Restarter(resource.Resource):
properties_schema = {'InstanceId': {'Type': 'String',
'Required': True}}
self.stack.restart_resource(victim.name)
-class Instance(resources.Resource):
+class Instance(resource.Resource):
# AWS does not require KeyName and InstanceType but we seem to
tags_schema = {'Key': {'Type': 'String',
'Required': True},
attachments.append((json.dumps(self.metadata),
'cfn-init-data', 'x-cfninitdata'))
- metadata_server = resources.Metadata.server()
+ metadata_server = resource.Metadata.server()
if metadata_server is not None:
attachments.append((metadata_server,
'cfn-metadata-server', 'x-cfninitdata'))
import json
from heat.common import exception
-from heat.engine import stack
+from heat.engine.resources import stack
from heat.db import api as db_api
from heat.engine import parser
from novaclient.exceptions import NotFound
Register of resource types and their mapping to Resource classes.
"""
-
-from heat.engine import resources
-
-from heat.engine import autoscaling
-from heat.engine import cloud_watch
-from heat.engine import dbinstance
-from heat.engine import eip
-from heat.engine import instance
-from heat.engine import loadbalancer
-from heat.engine import s3
-from heat.engine import security_group
-from heat.engine import stack
-from heat.engine import user
-from heat.engine import volume
-from heat.engine import wait_condition
+from heat.engine.resources import autoscaling
+from heat.engine.resources import cloud_watch
+from heat.engine.resources import dbinstance
+from heat.engine.resources import eip
+from heat.engine.resources import instance
+from heat.engine.resources import loadbalancer
+from heat.engine.resources import s3
+from heat.engine.resources import security_group
+from heat.engine.resources import stack
+from heat.engine.resources import user
+from heat.engine.resources import volume
+from heat.engine.resources import wait_condition
_resource_classes = {
}
-def getClass(resource_type):
- """Return the appropriate Resource class for the resource type."""
- return _resource_classes.get(resource_type, resources.GenericResource)
+def get_class(resource_type):
+ return _resource_classes.get(resource_type)
return super(Resource, cls).__new__(cls)
# Select the correct subclass to instantiate
- import resource_types
- ResourceClass = resource_types.getClass(json['Type'])
+ from heat.engine.resources import register
+ ResourceClass = register.get_class(json['Type']) or GenericResource
return ResourceClass(name, json, stack)
def __init__(self, name, json_snippet, stack):
from urlparse import urlparse
from heat.common import exception
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from heat.openstack.common import log as logging
try:
from swiftclient.client import ClientException
logger = logging.getLogger('heat.engine.s3')
-class S3Bucket(Resource):
+class S3Bucket(resource.Resource):
website_schema = {'IndexDocument': {'Type': 'String'},
'ErrorDocument': {'Type': 'String'}}
properties_schema = {'AccessControl': {
from novaclient.exceptions import BadRequest
from novaclient.exceptions import NotFound
from heat.common import exception
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.security_group')
-class SecurityGroup(Resource):
+class SecurityGroup(resource.Resource):
properties_schema = {'GroupDescription': {'Type': 'String',
'Required': True},
'VpcId': {'Type': 'String',
import json
from heat.common import exception
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from heat.db import api as db_api
from heat.engine import parser
PROP_PARAMETERS) = ('TemplateURL', 'TimeoutInMinutes', 'Parameters')
-class Stack(Resource):
+class Stack(resource.Resource):
properties_schema = {PROP_TEMPLATE_URL: {'Type': 'String',
'Required': True},
PROP_TIMEOUT_MINS: {'Type': 'Number'},
PROP_PARAMETERS: {'Type': 'Map'}}
def __init__(self, name, json_snippet, stack):
- Resource.__init__(self, name, json_snippet, stack)
+ super(Stack, self).__init__(name, json_snippet, stack)
self._nested = None
def _params(self):
import eventlet
from heat.common import exception
from heat.openstack.common import cfg
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from heat.openstack.common import log as logging
return self.id == other.id
-class User(Resource):
+class User(resource.Resource):
properties_schema = {'Path': {'Type': 'String'},
'Groups': {'Type': 'CommaDelimitedList'},
'LoginProfile': {'Type': 'List'},
resource=self.physical_resource_name(), key=key)
-class AccessKey(Resource):
+class AccessKey(resource.Resource):
properties_schema = {'Serial': {'Type': 'Integer',
'Implemented': False},
'UserName': {'Type': 'String',
from heat.openstack.common import log as logging
from heat.common import exception
-from heat.engine.resources import Resource
+from heat.engine.resources import resource
from novaclient.exceptions import NotFound
logger = logging.getLogger('heat.engine.volume')
-class Volume(Resource):
+class Volume(resource.Resource):
properties_schema = {'AvailabilityZone': {'Type': 'String',
'Required': True},
'Size': {'Type': 'Number'},
self.nova('volume').volumes.delete(self.instance_id)
-class VolumeAttachment(Resource):
+class VolumeAttachment(resource.Resource):
properties_schema = {'InstanceId': {'Type': 'String',
'Required': True},
'VolumeId': {'Type': 'String',
import eventlet
from heat.common import exception
-from heat.engine import resources
+from heat.engine.resources import resource
from heat.openstack.common import log as logging
logger = logging.getLogger('heat.engine.wait_condition')
-class WaitConditionHandle(resources.Resource):
+class WaitConditionHandle(resource.Resource):
'''
the main point of this class is to :
have no dependancies (so the instance can reference it)
def handle_create(self):
self.instance_id = '%s/stacks/%s/resources/%s' % \
- (resources.Metadata.server(),
+ (resource.Metadata.server(),
self.stack.id,
self.name)
)
-class WaitCondition(resources.Resource):
+class WaitCondition(resource.Resource):
properties_schema = {'Handle': {'Type': 'String',
'Required': True},
'Timeout': {'Type': 'Number',
from nose.plugins.attrib import attr
-from heat.engine import autoscaling as asc
-from heat.engine import loadbalancer
+from heat.engine.resources import autoscaling as asc
+from heat.engine.resources import loadbalancer
from heat.engine import parser
from nose.plugins.attrib import attr
from heat.common import exception
-from heat.engine import dbinstance as dbi
from heat.engine import parser
-from heat.engine import stack
+from heat.engine.resources import stack
+from heat.engine.resources import dbinstance as dbi
@attr(tag=['unit', 'resource'])
from nose.plugins.attrib import attr
-from heat.engine import eip
+from heat.engine.resources import eip
from heat.engine import parser
from heat.tests.v1_1 import fakes
from heat.common import context
from heat.tests.v1_1 import fakes
import heat.engine.api as engine_api
-from heat.engine import instance as instances
import heat.db as db_api
from heat.engine import parser
from heat.engine import manager
from heat.engine import auth
+from heat.engine.resources import instance as instances
from heat.engine import watchrule
from nose import with_setup
from heat.tests.v1_1 import fakes
-from heat.engine import instance as instances
+from heat.engine.resources import instance as instances
import heat.db as db_api
from heat.engine import parser
from nose.plugins.attrib import attr
from heat.common import exception
-from heat.engine import instance
-from heat.engine import loadbalancer as lb
from heat.engine import parser
-from heat.engine import resources
-from heat.engine import stack
+from heat.engine.resources import instance
+from heat.engine.resources import loadbalancer as lb
+from heat.engine.resources.resource import Metadata
+from heat.engine.resources import stack
from heat.tests.v1_1 import fakes
self.m.StubOutWithMock(lb.LoadBalancer, 'nova')
self.m.StubOutWithMock(instance.Instance, 'nova')
self.m.StubOutWithMock(self.fc.servers, 'create')
- self.m.StubOutWithMock(resources.Metadata, '__set__')
+ self.m.StubOutWithMock(Metadata, '__set__')
def tearDown(self):
self.m.UnsetStubs()
scheduler_hints=None, userdata=mox.IgnoreArg(),
security_groups=None).AndReturn(self.fc.servers.list()[1])
#stack.Stack.create_with_template(mox.IgnoreArg()).AndReturn(None)
- resources.Metadata.__set__(mox.IgnoreArg(),
- mox.IgnoreArg()).AndReturn(None)
+ Metadata.__set__(mox.IgnoreArg(),
+ mox.IgnoreArg()).AndReturn(None)
lb.LoadBalancer.nova().MultipleTimes().AndReturn(self.fc)
self.m.ReplayAll()
import json
from heat.common import context
from heat.engine import parser
-from heat.engine import resources
+from heat.engine.resources import resource
@attr(tag=['unit', 'resource'])
def test_state_defaults(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_res_def', tmpl, self.stack)
+ res = resource.GenericResource('test_res_def', tmpl, self.stack)
self.assertEqual(res.state, None)
self.assertEqual(res.state_description, '')
def test_state(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_resource', tmpl, self.stack)
+ res = resource.GenericResource('test_resource', tmpl, self.stack)
res.state_set('bar')
self.assertEqual(res.state, 'bar')
def test_state_description(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_resource', tmpl, self.stack)
+ res = resource.GenericResource('test_resource', tmpl, self.stack)
res.state_set('blarg', 'wibble')
self.assertEqual(res.state_description, 'wibble')
def test_created_time(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_res_new', tmpl, self.stack)
+ res = resource.GenericResource('test_res_new', tmpl, self.stack)
self.assertEqual(res.created_time, None)
res._store()
self.assertNotEqual(res.created_time, None)
def test_updated_time(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_res_upd', tmpl, self.stack)
+ res = resource.GenericResource('test_res_upd', tmpl, self.stack)
res._store()
stored_time = res.updated_time
res.state_set(res.CREATE_IN_PROGRESS, 'testing')
'Type': 'Foo',
'foo': {'Fn::Join': [' ', ['bar', 'baz', 'quux']]}
}
- res = resources.GenericResource('test_resource', tmpl, self.stack)
+ res = resource.GenericResource('test_resource', tmpl, self.stack)
parsed_tmpl = res.parsed_template()
self.assertEqual(parsed_tmpl['Type'], 'Foo')
def test_parsed_template_default(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_resource', tmpl, self.stack)
+ res = resource.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.parsed_template('foo'), {})
self.assertEqual(res.parsed_template('foo', 'bar'), 'bar')
def test_metadata_default(self):
tmpl = {'Type': 'Foo'}
- res = resources.GenericResource('test_resource', tmpl, self.stack)
+ res = resource.GenericResource('test_resource', tmpl, self.stack)
self.assertEqual(res.metadata, {})
ctx.username = 'metadata_test_user'
self.stack = parser.Stack(ctx, 'test_stack', parser.Template({}))
self.stack.store()
- self.res = resources.GenericResource('metadata_resource',
+ self.res = resource.GenericResource('metadata_resource',
tmpl, self.stack)
self.res.create()
from nose.plugins.attrib import attr
-from heat.engine import s3
+from heat.engine.resources import s3
from heat.engine import parser
from utils import skip_if
from heat.common import exception
from heat.common import config
from heat.engine import parser
-from heat.engine import user
+from heat.engine.resources import user
from heat.tests.v1_1 import fakes
from keystoneclient.v2_0 import users
from keystoneclient.v2_0 import roles
from nose import with_setup
from heat.tests.v1_1 import fakes
-from heat.engine import instance as instances
-from heat.engine import volume as volumes
+from heat.engine.resources import instance as instances
+from heat.engine.resources import volume as volumes
from heat.engine import manager as managers
import heat.db as db_api
from heat.engine import parser
from nose.plugins.attrib import attr
from heat.engine import parser
-from heat.engine import volume as vol
+from heat.engine.resources import volume as vol
from heat.tests.v1_1 import fakes
import heat.db as db_api
from heat.engine import parser
-from heat.engine import wait_condition as wc
+from heat.engine.resources import wait_condition as wc
from heat.common import context
logger = logging.getLogger('test_waitcondition')