raise ValueError('%s: %s Value must be a map' %
(self.name, key))
if 'Schema' in self.data[key]:
- cdict = Properties(key, self.data[key]['Schema'])
- cdict.data = self.data[key]['Schema']
+ cdict = CheckedDict(key)
+ schema = self.data[key]['Schema']
+ for n, s in schema.items():
+ cdict.addschema(n, s)
for k, v in value.items():
cdict[k] = v
(self.name, key, value))
if 'Schema' in self.data[key]:
for item in value:
- cdict = Properties(key, self.data[key]['Schema'])
+ cdict = CheckedDict(key)
+ schema = self.data[key]['Schema']
+ for n, s in schema.items():
+ cdict.addschema(n, s)
for k, v in item.items():
cdict[k] = v
def __delitem__(self, k):
del self.data[k]
-
-
-class Properties(CheckedDict):
- def __init__(self, name, schema):
- CheckedDict.__init__(self, name)
- self.data = deepcopy(schema)
-
- # set some defaults
- for s in self.data:
- if not 'Implemented' in self.data[s]:
- self.data[s]['Implemented'] = True
- if not 'Required' in self.data[s]:
- self.data[s]['Required'] = False
-
- def validate(self):
- for key in self.data:
- # are there missing required Properties
- if 'Required' in self.data[key]:
- if self.data[key]['Required'] \
- and not 'Value' in self.data[key]:
- return '%s Property must be provided' % key
-
- # are there unimplemented Properties
- if not self.data[key]['Implemented'] and 'Value' in self.data[key]:
- return '%s Property not implemented yet' % key
- return None
failures = []
with eventlet.Timeout(self.timeout_mins * 60) as tmo:
try:
- for res in self:
- res.calculate_properties()
-
# First delete any resources which are not in newstack
for res in reversed(self):
if not res.name in newstack.keys():
'''
self.state_set(self.DELETE_IN_PROGRESS, 'Stack deletion started')
- for res in self:
- res.calculate_properties()
-
failures = []
for res in reversed(self):
result = res.destroy()
deps = self.dependencies[self[resource_name]]
failed = False
- for res in self:
- res.calculate_properties()
-
for res in reversed(deps):
try:
res.destroy()
inst.destroy()
def adjust(self, adjustment, adjustment_type='ChangeInCapacity'):
- self.calculate_properties()
-
inst_list = []
if self.instance_id is not None:
inst_list = sorted(self.instance_id.split(','))
super(ScalingPolicy, self).__init__(name, json_snippet, stack)
def alarm(self):
- self.calculate_properties()
group = self.stack.resources[self.properties['AutoScalingGroupName']]
logger.info('%s Alarm, adjusting Group %s by %s' %
return None
def alarm(self):
- self.calculate_properties()
victim = self._find_resource(self.properties['InstanceId'])
if victim is None:
from heat.common import exception
from heat.common import config
from heat.db import api as db_api
-from heat.engine import checkeddict
from heat.engine import timestamp
+from heat.engine.resources.properties import Properties
from heat.openstack.common import log as logging
from heat.openstack.common import cfg
self.context = stack.context
self.name = name
self.t = stack.resolve_static_data(json_snippet)
- self.properties = checkeddict.Properties(name, self.properties_schema)
+ self.properties = Properties(self.properties_schema,
+ self.t.get('Properties', {}),
+ self.stack.resolve_runtime_data,
+ self.name)
resource = db_api.resource_get_by_name_and_stack(self.context,
name, stack.id)
return self._quantum
- def calculate_properties(self):
- for p, v in self.parsed_template('Properties').items():
- self.properties[p] = v
-
def create(self):
'''
Create the resource. Subclasses should provide a handle_create() method
logger.info('creating %s' % str(self))
try:
- self.calculate_properties()
self.properties.validate()
self.state_set(self.CREATE_IN_PROGRESS)
if callable(getattr(self, 'handle_create', None)):
try:
self.state_set(self.UPDATE_IN_PROGRESS)
self.t = self.stack.resolve_static_data(json_snippet)
- self.properties = checkeddict.Properties(self.name,
- self.properties_schema)
- self.calculate_properties()
self.properties.validate()
if callable(getattr(self, 'handle_update', None)):
result = self.handle_update()
def validate(self):
logger.info('Validating %s' % str(self))
- try:
- self.calculate_properties()
- except ValueError as ex:
- return str(ex)
return self.properties.validate()
def delete(self):
def _add_event(self, new_state, reason):
'''Add a state change event to the database'''
- self.calculate_properties()
ev = {'logical_resource_id': self.name,
'physical_resource_id': self.instance_id,
'stack_id': self.stack.id,
def FnGetAtt(self, key):
res = None
log_res = None
- self.calculate_properties()
if key == 'UserName':
res = self.properties['UserName']
log_res = res
def _get_handle_resource_id(self):
if self.resource_id is None:
- self.calculate_properties()
handle_url = self.properties['Handle']
self.resource_id = handle_url.split('/')[-1]
return self.resource_id
instances.Instance.nova().MultipleTimes().AndReturn(fc)
instance = stack.resources['WebServer']
- instance.calculate_properties()
server_userdata = instance._build_userdata(instance.properties['UserData'])
mocks.StubOutWithMock(fc.servers, 'create')
fc.servers.create(image=744, flavor=3, key_name='test',
'UnhealthyThreshold': '5',
'Interval': '30',
'Timeout': '5'}
- resource.properties['HealthCheck'] = hc
+ resource.t['Properties']['HealthCheck'] = hc
self.assertEqual(None, resource.validate())
hc['Timeout'] = 35
from nose.plugins.attrib import attr
from heat.common import exception
-from heat.engine import checkeddict
+from heat.engine.resources import properties
from heat.engine.resources.quantum import net
from heat.engine.resources.quantum.quantum import QuantumResource as qr
from heat.engine import parser
return resource
def test_validate_properties(self):
- p = checkeddict.Properties('foo', net.Net.properties_schema)
vs = {'router:external': True}
- p.update({
+ data = {
'admin_state_up': False,
'value_specs': vs
- })
+ }
+ p = properties.Properties(net.Net.properties_schema, data)
self.assertEqual(None, qr.validate_properties(p))
vs['shared'] = True
self.assertEqual(None, qr.validate_properties(p))
def test_prepare_properties(self):
- p = checkeddict.Properties('foo', net.Net.properties_schema)
- p.update({
+ data = {
'admin_state_up': False,
'value_specs': {'router:external': True}
- })
+ }
+ p = properties.Properties(net.Net.properties_schema, data)
props = qr.prepare_properties(p, 'resource_name')
self.assertEqual({
'name': 'resource_name',
'Schema': listeners_schema}
}
- cd = checkeddict.Properties('nested', properties_schema)
+ cd = checkeddict.CheckedDict('nested')
+ for p, s in properties_schema.items():
+ cd.addschema(p, s)
hc = {'HealthyThreshold': 'bla', 'Interval': '45'}
self.assertRaises(ValueError, cd.__setitem__, 'HealthCheck', hc)
Code Review / openstack-build / heat-build.git / commitdiff