class SoftwareConfig(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'name': fields.StringField(nullable=True),
'group': fields.StringField(nullable=True),
'tenant': fields.StringField(nullable=True),
'config': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, config, db_config):
# SoftwareDeployment._from_db_object may attempt to load a None config
if db_config is None:
return None
for field in config.fields:
config[field] = db_config[field]
config._context = context
config.obj_reset_changes()
return config
@classmethod
def create(cls, context, values):
return cls._from_db_object(
context, cls(), db_api.software_config_create(context, values))
@classmethod
def get_by_id(cls, context, config_id):
return cls._from_db_object(
context, cls(), db_api.software_config_get(context, config_id))
@classmethod
def get_all(cls, context, **kwargs):
scs = db_api.software_config_get_all(context, **kwargs)
return [cls._from_db_object(context, cls(), sc) for sc in scs]
@classmethod
def delete(cls, context, config_id):
db_api.software_config_delete(context, config_id)
class WatchData(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
):
fields = {
'id': fields.IntegerField(),
'data': heat_fields.JsonField(nullable=True),
'watch_rule_id': fields.StringField(),
'watch_rule': fields.ObjectField('WatchRule'),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, rule, db_data):
from conveyor.conveyorheat.objects import watch_rule
for field in rule.fields:
if field == 'watch_rule':
rule[field] = watch_rule.WatchRule._from_db_object(
context,
watch_rule.WatchRule(),
db_data['watch_rule'])
else:
rule[field] = db_data[field]
rule._context = context
rule.obj_reset_changes()
return rule
@classmethod
def create(cls, context, values):
db_data = db_api.watch_data_create(context, values)
return cls._from_db_object(context, cls(), db_data)
@classmethod
def get_all(cls, context):
return [cls._from_db_object(context, cls(), db_data)
for db_data in db_api.watch_data_get_all(context)]
@classmethod
def get_all_by_watch_rule_id(cls, context, watch_rule_id):
return (cls._from_db_object(context, cls(), db_data)
for db_data in db_api.watch_data_get_all_by_watch_rule_id(
context, watch_rule_id))
class WatchRule(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
):
fields = {
'id': fields.IntegerField(),
'name': fields.StringField(nullable=True),
'rule': heat_fields.JsonField(nullable=True),
'state': fields.StringField(nullable=True),
'last_evaluated': fields.DateTimeField(nullable=True),
'stack_id': fields.StringField(),
'stack': fields.ObjectField(stack.Stack),
'watch_data': fields.ListOfObjectsField(watch_data.WatchData),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, rule, db_rule):
for field in rule.fields:
if field == 'stack':
rule[field] = stack.Stack._from_db_object(
context, stack.Stack(), db_rule[field])
elif field == 'watch_data':
rule[field] = watch_data.WatchData.get_all_by_watch_rule_id(
context, db_rule['id'])
else:
rule[field] = db_rule[field]
rule._context = context
rule.obj_reset_changes()
return rule
@classmethod
def get_by_id(cls, context, rule_id):
db_rule = db_api.watch_rule_get(context, rule_id)
return cls._from_db_object(context, cls(), db_rule)
@classmethod
def get_by_name(cls, context, watch_rule_name):
db_rule = db_api.watch_rule_get_by_name(context, watch_rule_name)
return cls._from_db_object(context, cls(), db_rule)
@classmethod
def get_all(cls, context):
return [cls._from_db_object(context, cls(), db_rule)
for db_rule in db_api.watch_rule_get_all(context)]
@classmethod
def get_all_by_stack(cls, context, stack_id):
return [cls._from_db_object(context, cls(), db_rule)
for db_rule in db_api.watch_rule_get_all_by_stack(context,
stack_id)]
@classmethod
def update_by_id(cls, context, watch_id, values):
db_api.watch_rule_update(context, watch_id, values)
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.watch_rule_create(context, values))
@classmethod
def delete(cls, context, watch_id):
db_api.watch_rule_delete(context, watch_id)
class SoftwareDeployment(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'config_id': fields.StringField(),
'server_id': fields.StringField(),
'input_values': heat_fields.JsonField(nullable=True),
'output_values': heat_fields.JsonField(nullable=True),
'tenant': fields.StringField(),
'stack_user_project_id': fields.StringField(nullable=True),
'action': fields.StringField(nullable=True),
'status': fields.StringField(nullable=True),
'status_reason': fields.StringField(nullable=True),
'config': fields.ObjectField('SoftwareConfig'),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, deployment, db_deployment):
for field in deployment.fields:
if field == 'config':
deployment[field] = (
software_config.SoftwareConfig._from_db_object(
context, software_config.SoftwareConfig(),
db_deployment['config']))
else:
deployment[field] = db_deployment[field]
deployment._context = context
deployment.obj_reset_changes()
return deployment
@classmethod
def create(cls, context, values):
return cls._from_db_object(
context, cls(), db_api.software_deployment_create(context, values))
@classmethod
def get_by_id(cls, context, deployment_id):
return cls._from_db_object(
context, cls(),
db_api.software_deployment_get(context, deployment_id))
@classmethod
def get_all(cls, context, server_id=None):
return [
cls._from_db_object(context, cls(), db_deployment)
for db_deployment in db_api.software_deployment_get_all(
context, server_id)
]
@classmethod
def update_by_id(cls, context, deployment_id, values):
"""Note this is a bit unusual as it returns the object.
Other update_by_id methods return a bool (was it updated).
"""
return cls._from_db_object(
context, cls(),
db_api.software_deployment_update(context, deployment_id, values))
@classmethod
def delete(cls, context, deployment_id):
db_api.software_deployment_delete(context, deployment_id)
class Resource(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id':
fields.IntegerField(),
'uuid':
fields.StringField(),
'stack_id':
fields.StringField(),
'created_at':
fields.DateTimeField(read_only=True),
'updated_at':
fields.DateTimeField(nullable=True),
'nova_instance':
fields.StringField(nullable=True),
'name':
fields.StringField(nullable=True),
'status':
fields.StringField(nullable=True),
'status_reason':
fields.StringField(nullable=True),
'action':
fields.StringField(nullable=True),
'rsrc_metadata':
heat_fields.JsonField(nullable=True),
'properties_data':
heat_fields.JsonField(nullable=True),
'properties_data_encrypted':
fields.BooleanField(default=False),
'data':
fields.ListOfObjectsField(resource_data.ResourceData, nullable=True),
'stack':
fields.ObjectField(stack.Stack),
'engine_id':
fields.StringField(nullable=True),
'atomic_key':
fields.IntegerField(nullable=True),
'current_template_id':
fields.IntegerField(),
'needed_by':
heat_fields.ListField(nullable=True, default=None),
'requires':
heat_fields.ListField(nullable=True, default=None),
'replaces':
fields.IntegerField(nullable=True),
'replaced_by':
fields.IntegerField(nullable=True),
'root_stack_id':
fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(resource, context, db_resource):
if db_resource is None:
return None
for field in resource.fields:
if field == 'data':
resource['data'] = [
resource_data.ResourceData._from_db_object(
resource_data.ResourceData(context), resd)
for resd in db_resource.data
]
else:
resource[field] = db_resource[field]
if resource.properties_data_encrypted and resource.properties_data:
properties_data = {}
for prop_name, prop_value in resource.properties_data.items():
method, value = prop_value
decrypted_value = crypt.decrypt(method, value)
prop_string = jsonutils.loads(decrypted_value)
properties_data[prop_name] = prop_string
resource.properties_data = properties_data
resource._context = context
resource.obj_reset_changes()
return resource
@classmethod
def get_obj(cls, context, resource_id):
resource_db = db_api.resource_get(context, resource_id)
return cls._from_db_object(cls(context), context, resource_db)
@classmethod
def get_all(cls, context):
resources_db = db_api.resource_get_all(context)
resources = [
(resource_name,
cls._from_db_object(cls(context), context, resource_db))
for resource_name, resource_db in six.iteritems(resources_db)
]
return dict(resources)
@classmethod
def create(cls, context, values):
return cls._from_db_object(cls(context), context,
db_api.resource_create(context, values))
@classmethod
def delete(cls, context, resource_id):
resource_db = db_api.resource_get(context, resource_id)
resource_db.delete()
@classmethod
def exchange_stacks(cls, context, resource_id1, resource_id2):
return db_api.resource_exchange_stacks(context, resource_id1,
resource_id2)
@classmethod
def get_all_by_stack(cls, context, stack_id, key_id=False, filters=None):
resources_db = db_api.resource_get_all_by_stack(
context, stack_id, key_id, filters)
resources = [
(resource_key,
cls._from_db_object(cls(context), context, resource_db))
for resource_key, resource_db in six.iteritems(resources_db)
]
return dict(resources)
@classmethod
def get_by_name_and_stack(cls, context, resource_name, stack_id):
resource_db = db_api.resource_get_by_name_and_stack(
context, resource_name, stack_id)
return cls._from_db_object(cls(context), context, resource_db)
@classmethod
def get_by_physical_resource_id(cls, context, physical_resource_id):
resource_db = db_api.resource_get_by_physical_resource_id(
context, physical_resource_id)
return cls._from_db_object(cls(context), context, resource_db)
@classmethod
def update_by_id(cls, context, resource_id, values):
resource_db = db_api.resource_get(context, resource_id)
resource_db.update_and_save(values)
def update_and_save(self, values):
resource_db = db_api.resource_get(self._context, self.id)
resource_db.update_and_save(values)
def select_and_update(self, values, expected_engine_id=None, atomic_key=0):
return db_api.resource_update(self._context,
self.id,
values,
atomic_key=atomic_key,
expected_engine_id=expected_engine_id)
def refresh(self, attrs=None):
resource_db = db_api.resource_get(self._context, self.id)
resource_db.refresh(attrs=attrs)
return self.__class__._from_db_object(self, self._context, resource_db)
@staticmethod
def encrypt_properties_data(data):
if cfg.CONF.encrypt_parameters_and_properties and data:
result = {}
for prop_name, prop_value in data.items():
prop_string = jsonutils.dumps(prop_value)
encrypted_value = crypt.encrypt(prop_string)
result[prop_name] = encrypted_value
return (True, result)
return (False, data)
def update_metadata(self, metadata):
if self.rsrc_metadata != metadata:
rows_updated = self.select_and_update({'rsrc_metadata': metadata},
self.engine_id,
self.atomic_key)
if not rows_updated:
action = _('metadata setting for resource %s') % self.name
raise exception.ConcurrentTransaction(action=action)
class Stack(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'name': fields.StringField(),
'raw_template_id': fields.IntegerField(),
'backup': fields.BooleanField(),
'created_at': fields.DateTimeField(read_only=True),
'deleted_at': fields.DateTimeField(nullable=True),
'disable_rollback': fields.BooleanField(),
'nested_depth': fields.IntegerField(),
'owner_id': fields.StringField(nullable=True),
'stack_user_project_id': fields.StringField(nullable=True),
'tenant': fields.StringField(nullable=True),
'timeout': fields.IntegerField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'user_creds_id': fields.StringField(nullable=True),
'username': fields.StringField(nullable=True),
'action': fields.StringField(nullable=True),
'status': fields.StringField(nullable=True),
'status_reason': fields.StringField(nullable=True),
'raw_template': fields.ObjectField('RawTemplate'),
'convergence': fields.BooleanField(),
'current_traversal': fields.StringField(),
'current_deps': heat_fields.JsonField(),
'prev_raw_template_id': fields.IntegerField(),
'prev_raw_template': fields.ObjectField('RawTemplate'),
'tags': fields.ObjectField('StackTagList'),
'parent_resource_name': fields.StringField(nullable=True),
}
@staticmethod
def _from_db_object(context, stack, db_stack):
for field in stack.fields:
if field == 'raw_template':
stack['raw_template'] = (raw_template.RawTemplate.get_by_id(
context, db_stack['raw_template_id']))
elif field == 'tags':
stack['tags'] = stack_tag.StackTagList.from_db_object(
context, db_stack.get(field))
else:
stack[field] = db_stack.__dict__.get(field)
stack._context = context
stack.obj_reset_changes()
return stack
@classmethod
def get_root_id(cls, context, stack_id):
return db_api.stack_get_root_id(context, stack_id)
@classmethod
def get_by_id(cls, context, stack_id, **kwargs):
db_stack = db_api.stack_get(context, stack_id, **kwargs)
if not db_stack:
return None
stack = cls._from_db_object(context, cls(context), db_stack)
return stack
@classmethod
def get_by_name_and_owner_id(cls, context, stack_name, owner_id):
db_stack = db_api.stack_get_by_name_and_owner_id(
context, six.text_type(stack_name), owner_id)
if not db_stack:
return None
stack = cls._from_db_object(context, cls(context), db_stack)
return stack
@classmethod
def get_by_name(cls, context, stack_name):
db_stack = db_api.stack_get_by_name(context, six.text_type(stack_name))
if not db_stack:
return None
stack = cls._from_db_object(context, cls(context), db_stack)
return stack
@classmethod
def get_all(cls, context, *args, **kwargs):
db_stacks = db_api.stack_get_all(context, *args, **kwargs)
for db_stack in db_stacks:
try:
yield cls._from_db_object(context, cls(context), db_stack)
except exception.NotFound:
pass
@classmethod
def get_all_by_owner_id(cls, context, owner_id):
db_stacks = db_api.stack_get_all_by_owner_id(context, owner_id)
for db_stack in db_stacks:
try:
yield cls._from_db_object(context, cls(context), db_stack)
except exception.NotFound:
pass
@classmethod
def count_all(cls, context, **kwargs):
return db_api.stack_count_all(context, **kwargs)
@classmethod
def count_total_resources(cls, context, stack_id):
return db_api.stack_count_total_resources(context, stack_id)
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(context),
db_api.stack_create(context, values))
@classmethod
def update_by_id(cls, context, stack_id, values):
"""Update and return (boolean) if it was updated.
Note: the underlying stack_update filters by current_traversal
and stack_id.
"""
return db_api.stack_update(context, stack_id, values)
@classmethod
def select_and_update(cls, context, stack_id, values, exp_trvsl=None):
"""Update the stack by selecting on traversal ID.
Uses UPDATE ... WHERE (compare and swap) to catch any concurrent
update problem.
If the stack is found with given traversal, it is updated.
If there occurs a race while updating, only one will succeed and
other will get return value of False.
"""
return db_api.stack_update(context,
stack_id,
values,
exp_trvsl=exp_trvsl)
@classmethod
def persist_state_and_release_lock(cls, context, stack_id, engine_id,
values):
return db_api.persist_state_and_release_lock(context, stack_id,
engine_id, values)
@classmethod
def delete(cls, context, stack_id):
db_api.stack_delete(context, stack_id)
def update_and_save(self, values):
has_updated = self.__class__.update_by_id(self._context, self.id,
values)
if not has_updated:
raise exception.NotFound(
_('Attempt to update a stack with id: '
'%(id)s %(traversal)s %(msg)s') % {
'id': self.id,
'traversal': self.current_traversal,
'msg': 'that does not exist'
})
def __eq__(self, another):
self.refresh() # to make test object comparison work well
return super(Stack, self).__eq__(another)
def refresh(self):
db_stack = db_api.stack_get(self._context, self.id, show_deleted=True)
if db_stack is None:
message = _('No stack exists with id "%s"') % str(self.id)
raise exception.NotFound(message)
return self.__class__._from_db_object(self._context, self, db_stack)
@classmethod
def encrypt_hidden_parameters(cls, tmpl):
raw_template.RawTemplate.encrypt_hidden_parameters(tmpl)
@classmethod
def get_status(cls, context, stack_id):
"""Return action and status for the given stack."""
return db_api.stack_get_status(context, stack_id)
class RawTemplate(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'id': fields.StringField(),
'files': heat_fields.JsonField(nullable=True),
'template': heat_fields.JsonField(),
'environment': heat_fields.JsonField(),
}
@staticmethod
def _from_db_object(context, tpl, db_tpl):
for field in tpl.fields:
tpl[field] = db_tpl[field]
tpl.environment = copy.deepcopy(tpl.environment)
# If any of the parameters were encrypted, then decrypt them
if (tpl.environment is not None
and env_fmt.ENCRYPTED_PARAM_NAMES in tpl.environment):
parameters = tpl.environment[env_fmt.PARAMETERS]
encrypted_param_names = tpl.environment[
env_fmt.ENCRYPTED_PARAM_NAMES]
for param_name in encrypted_param_names:
method, value = parameters[param_name]
decrypted_val = crypt.decrypt(method, value)
parameters[param_name] = decrypted_val
tpl.environment[env_fmt.PARAMETERS] = parameters
tpl._context = context
tpl.obj_reset_changes()
return tpl
@classmethod
def get_by_id(cls, context, template_id):
raw_template_db = db_api.raw_template_get(context, template_id)
return cls._from_db_object(context, cls(), raw_template_db)
@classmethod
def encrypt_hidden_parameters(cls, tmpl):
if cfg.CONF.encrypt_parameters_and_properties:
for param_name, param in tmpl.env.params.items():
if not tmpl.param_schemata()[param_name].hidden:
continue
clear_text_val = tmpl.env.params.get(param_name)
tmpl.env.params[param_name] = crypt.encrypt(clear_text_val)
if param_name not in tmpl.env.encrypted_param_names:
tmpl.env.encrypted_param_names.append(param_name)
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.raw_template_create(context, values))
@classmethod
def update_by_id(cls, context, template_id, values):
return cls._from_db_object(
context, cls(),
db_api.raw_template_update(context, template_id, values))
@classmethod
def delete(cls, context, template_id):
db_api.raw_template_delete(context, template_id)
class SyncPoint(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
base.ComparableVersionedObject,
):
fields = {
'entity_id': fields.StringField(),
'traversal_id': fields.StringField(),
'is_update': fields.BooleanField(),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
'atomic_key': fields.IntegerField(),
'stack_id': fields.StringField(),
'input_data': heat_fields.JsonField(nullable=True),
}
@staticmethod
def _from_db_object(context, sdata, db_sdata):
if db_sdata is None:
return None
for field in sdata.fields:
sdata[field] = db_sdata[field]
sdata._context = context
sdata.obj_reset_changes()
return sdata
@classmethod
def get_by_key(cls,
context,
entity_id,
traversal_id,
is_update):
sync_point_db = db_api.sync_point_get(context,
entity_id,
traversal_id,
is_update)
return cls._from_db_object(context, cls(), sync_point_db)
@classmethod
def create(cls, context, values):
sync_point_db = db_api.sync_point_create(context, values)
return cls._from_db_object(context, cls(), sync_point_db)
@classmethod
def update_input_data(cls,
context,
entity_id,
traversal_id,
is_update,
atomic_key,
input_data):
return db_api.sync_point_update_input_data(
context,
entity_id,
traversal_id,
is_update,
atomic_key,
input_data)
@classmethod
def delete_all_by_stack_and_traversal(cls,
context,
stack_id,
traversal_id):
return db_api.sync_point_delete_all_by_stack_and_traversal(
context,
stack_id,
traversal_id)
class Event(
heat_base.HeatObject,
base.VersionedObjectDictCompat,
):
fields = {
'id': fields.IntegerField(),
'stack_id': fields.StringField(),
'uuid': fields.StringField(),
'resource_action': fields.StringField(nullable=True),
'resource_status': fields.StringField(nullable=True),
'resource_name': fields.StringField(nullable=True),
'physical_resource_id': fields.StringField(nullable=True),
'resource_status_reason': fields.StringField(nullable=True),
'resource_type': fields.StringField(nullable=True),
'resource_properties': heat_fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(read_only=True),
'updated_at': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, event, db_event):
for field in event.fields:
event[field] = db_event[field]
event._context = context
event.obj_reset_changes()
return event
@classmethod
def get_by_id(cls, context, event_id):
db_event = db_api.event_get(context, event_id)
return cls._from_db_object(context, cls(context), db_event)
@classmethod
def get_all(cls, context):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all(context)
]
@classmethod
def get_all_by_tenant(cls, context, **kwargs):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all_by_tenant(context, **kwargs)
]
@classmethod
def get_all_by_stack(cls, context, stack_id, **kwargs):
return [
cls._from_db_object(context, cls(), db_event)
for db_event in db_api.event_get_all_by_stack(
context, stack_id, **kwargs)
]
@classmethod
def count_all_by_stack(cls, context, stack_id):
return db_api.event_count_all_by_stack(context, stack_id)
@classmethod
def create(cls, context, values):
return cls._from_db_object(context, cls(),
db_api.event_create(context, values))