class NodeAdoptRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'type': fields.StringField(),
'overrides': fields.JsonField(nullable=True),
'preview': fields.BooleanField(default=True),
'snapshot': fields.BooleanField(default=False)
}
class ClusterResizeRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'adjustment_type': fields.AdjustmentTypeField(nullable=True),
'number': fields.FloatField(nullable=True),
'min_size': fields.CapacityField(nullable=True, minimum=0),
'max_size': fields.CapacityField(nullable=True, minimum=-1),
'min_step': fields.NonNegativeIntegerField(nullable=True),
'strict': fields.BooleanField(nullable=True, default=True),
'health_check': fields.BooleanField(nullable=True, default=False)
}
class ClusterScaleOutRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'count': fields.NonNegativeIntegerField(nullable=True),
'health_check': fields.BooleanField(nullable=True, default=False)
}
class ClusterUpdateRequest(base.SenlinObject):
# VERSION 1.0: initial version
# VERSION 1.1: added field 'profile_only'
# VERSION 1.2: added field 'config'
VERSION = '1.2'
VERSION_MAP = {
'1.6': '1.1',
'1.7': '1.2',
}
fields = {
'identity': fields.StringField(),
'name': fields.NameField(nullable=True),
'profile_id': fields.StringField(nullable=True),
'metadata': fields.JsonField(nullable=True),
'timeout': fields.NonNegativeIntegerField(nullable=True),
'profile_only': fields.BooleanField(nullable=True),
'config': fields.JsonField(nullable=True),
}
def obj_make_compatible(self, primitive, target_version):
super(ClusterUpdateRequest, self).obj_make_compatible(
primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
if 'profile_only' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['profile_only']
if target_version < (1, 2):
if 'config' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['config']
def setUp(self):
super(TestBoolean, self).setUp()
self.field = senlin_fields.BooleanField()
self.coerce_good_values = [
('True', True),
('T', True),
('t', True),
('1', True),
('yes', True),
('on', True),
('False', False),
('F', False),
('f', False),
('0', False),
('no', False),
('off', False)
]
self.coerce_bad_values = ['BOGUS']
self.to_primitive_values = [
(True, True),
(False, False)
]
self.from_primitive_values = [
('True', 'True'),
('False', 'False')
]
class ClusterUpdatePolicyRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'policy_id': fields.StringField(),
'enabled': fields.BooleanField(nullable=True, default=True),
}
class ActionUpdateRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'status': fields.StringField(),
'force': fields.BooleanField(default=False)
}
class HealthRegistry(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin health registry object."""
fields = {
'id': fields.UUIDField(),
'cluster_id': fields.UUIDField(),
'check_type': fields.StringField(),
'interval': fields.IntegerField(nullable=True),
'params': fields.JsonField(nullable=True),
'engine_id': fields.UUIDField(),
'enabled': fields.BooleanField(),
}
@classmethod
def create(cls, context, cluster_id, check_type, interval, params,
engine_id, enabled=True):
obj = db_api.registry_create(context, cluster_id, check_type,
interval, params, engine_id,
enabled=enabled)
return cls._from_db_object(context, cls(), obj)
@classmethod
def update(cls, context, cluster_id, values):
db_api.registry_update(context, cluster_id, values)
@classmethod
def claim(cls, context, engine_id):
objs = db_api.registry_claim(context, engine_id)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def delete(cls, context, cluster_id):
db_api.registry_delete(context, cluster_id)
@classmethod
def get(cls, context, cluster_id):
obj = db_api.registry_get(context, cluster_id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_engine(cls, context, engine_id, cluster_id):
params = {
"cluster_id": cluster_id,
"engine_id": engine_id,
}
obj = db_api.registry_get_by_param(context, params)
return cls._from_db_object(context, cls(), obj)
@classmethod
def disable_registry(cls, context, cluster_id):
cls.update(context, cluster_id, {'enabled': False})
@classmethod
def enable_registry(cls, context, cluster_id):
cls.update(context, cluster_id, {"enabled": True})
class NodeAdoptRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'type': fields.StringField(),
'name': fields.NameField(nullable=True),
'role': fields.StringField(nullable=True),
'metadata': fields.JsonField(nullable=True, default={}),
'overrides': fields.JsonField(nullable=True),
'snapshot': fields.BooleanField(nullable=True, default=False)
}
class ClusterPolicyListRequest(base.SenlinObject):
fields = {
'identity':
fields.StringField(),
'policy_name':
fields.NameField(nullable=True),
'policy_type':
fields.StringField(nullable=True),
'enabled':
fields.BooleanField(nullable=True),
'sort':
fields.SortField(valid_keys=list(consts.CLUSTER_POLICY_SORT_KEYS),
nullable=True)
}
class Service(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin service object."""
fields = {
'id': fields.UUIDField(),
'host': fields.StringField(),
'binary': fields.StringField(),
'topic': fields.StringField(),
'disabled': fields.BooleanField(),
'disabled_reason': fields.StringField(nullable=True),
'created_at': fields.DateTimeField(),
'updated_at': fields.DateTimeField(),
}
@classmethod
def create(cls, context, service_id, host=None, binary=None, topic=None):
obj = db_api.service_create(service_id,
host=host,
binary=binary,
topic=topic)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, service_id):
obj = db_api.service_get(service_id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_all(cls, context):
objs = db_api.service_get_all()
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def update(cls, context, obj_id, values=None):
obj = db_api.service_update(obj_id, values=values)
return cls._from_db_object(context, cls(), obj)
@classmethod
def delete(cls, obj_id):
db_api.service_delete(obj_id)
@classmethod
def gc_by_engine(cls, engine_id):
db_api.gc_by_engine(engine_id)
class ClusterDeleteRequest(base.SenlinObject):
# VERSION 1.0: Initial version
# VERSION 1.1 Added field 'force'
VERSION = '1.1'
VERSION_MAP = {
'1.8': '1.1',
}
fields = {
'identity': fields.StringField(),
'force': fields.BooleanField(default=False)
}
def obj_make_compatible(self, primitive, target_version):
super(ClusterDeleteRequest, self).obj_make_compatible(
primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
if 'force' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['force']
class NodeUpdateRequest(base.SenlinObject):
VERSION = '1.1'
VERSION_MAP = {'1.13': '1.1'}
fields = {
'identity': fields.StringField(),
'metadata': fields.JsonField(nullable=True),
'name': fields.NameField(nullable=True),
'profile_id': fields.StringField(nullable=True),
'role': fields.StringField(nullable=True),
'tainted': fields.BooleanField(nullable=True)
}
def obj_make_compatible(self, primitive, target_version):
super(NodeUpdateRequest,
self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 13):
if 'tainted' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['tainted']
class ClusterDelNodesRequest(base.SenlinObject):
# VERSION 1.0: Initial version
# VERSION 1.1: Add field 'destroy_after_deletion'
VERSION = '1.1'
VERSION_MAP = {
'1.4': '1.1',
}
fields = {
'identity': fields.StringField(),
'nodes': fields.IdentityListField(min_items=1),
'destroy_after_deletion': fields.BooleanField(nullable=True,
default=False)
}
def obj_make_compatible(self, primitive, target_version):
super(ClusterDelNodesRequest, self).obj_make_compatible(
primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
if 'destroy_after_deletion' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['destroy_after_deletion']
class ClusterPolicy(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin cluster-policy binding object."""
fields = {
'id': fields.UUIDField(),
'cluster_id': fields.UUIDField(),
'policy_id': fields.UUIDField(),
'cluster': fields.ObjectField('Cluster', nullable=True),
'policy': fields.ObjectField('Policy', nullable=True),
'enabled': fields.BooleanField(),
'priority': fields.IntegerField(),
'data': fields.JsonField(nullable=True),
'last_op': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, binding, db_obj):
if db_obj is None:
return None
for field in binding.fields:
if field == 'cluster':
c = cluster_obj.Cluster.get(context, db_obj['cluster_id'])
binding['cluster'] = c
elif field == 'policy':
p = policy_obj.Policy.get(context, db_obj['policy_id'])
binding['policy'] = p
else:
binding[field] = db_obj[field]
binding._context = context
binding.obj_reset_changes()
return binding
@classmethod
def create(cls, context, cluster_id, policy_id, values):
obj = db_api.cluster_policy_attach(context, cluster_id, policy_id,
values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, cluster_id, policy_id):
obj = db_api.cluster_policy_get(context, cluster_id, policy_id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_type(cls, context, cluster_id, policy_type, filters=None):
objs = db_api.cluster_policy_get_by_type(context,
cluster_id,
policy_type,
filters=filters)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def get_all(cls, context, cluster_id, **kwargs):
objs = db_api.cluster_policy_get_all(context, cluster_id, **kwargs)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def update(cls, context, cluster_id, policy_id, values):
db_api.cluster_policy_update(context, cluster_id, policy_id, values)
@classmethod
def delete(cls, context, cluster_id, policy_id):
db_api.cluster_policy_detach(context, cluster_id, policy_id)
class ClusterPolicy(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin cluster-policy binding object."""
fields = {
'id': fields.UUIDField(),
'cluster_id': fields.UUIDField(),
'policy_id': fields.UUIDField(),
'cluster': fields.ObjectField('Cluster', nullable=True),
'policy': fields.ObjectField('Policy', nullable=True),
'enabled': fields.BooleanField(),
'priority': fields.IntegerField(),
'data': fields.JsonField(nullable=True),
'last_op': fields.DateTimeField(nullable=True),
}
@staticmethod
def _from_db_object(context, binding, db_obj):
if db_obj is None:
return None
for field in binding.fields:
if field == 'cluster':
c = cluster_obj.Cluster.get(context, db_obj['cluster_id'])
binding['cluster'] = c
elif field == 'policy':
p = policy_obj.Policy.get(context, db_obj['policy_id'])
binding['policy'] = p
else:
binding[field] = db_obj[field]
binding._context = context
binding.obj_reset_changes()
return binding
@classmethod
def create(cls, context, cluster_id, policy_id, values):
obj = db_api.cluster_policy_attach(context, cluster_id, policy_id,
values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, cluster_id, policy_id):
obj = db_api.cluster_policy_get(context, cluster_id, policy_id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_type(cls, context, cluster_id, policy_type, filters=None):
objs = db_api.cluster_policy_get_by_type(context, cluster_id,
policy_type, filters=filters)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def get_all(cls, context, cluster_id, **kwargs):
objs = db_api.cluster_policy_get_all(context, cluster_id, **kwargs)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def update(cls, context, cluster_id, policy_id, values):
db_api.cluster_policy_update(context, cluster_id, policy_id, values)
@classmethod
def delete(cls, context, cluster_id, policy_id):
db_api.cluster_policy_detach(context, cluster_id, policy_id)
def cooldown_inprogress(self, cooldown):
last_op = self.last_op
if last_op and not timeutils.is_older_than(last_op, cooldown):
return True
return False
def to_dict(self):
binding_dict = {
'id': self.id,
'cluster_id': self.cluster.id,
'policy_id': self.policy.id,
'enabled': self.enabled,
'data': self.data,
'last_op': self.last_op,
'priority': self.priority,
# below are derived data for user's convenience
'cluster_name': self.cluster.name,
'policy_name': self.policy.name,
'policy_type': self.policy.type,
}
return binding_dict
class Node(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin node object."""
fields = {
'id': fields.UUIDField(),
'name': fields.StringField(),
'profile_id': fields.UUIDField(),
'cluster_id': fields.StringField(),
'physical_id': fields.StringField(nullable=True),
'index': fields.IntegerField(),
'role': fields.StringField(nullable=True),
'init_at': fields.DateTimeField(),
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'status': fields.StringField(),
'status_reason': fields.StringField(nullable=True),
'metadata': fields.JsonField(nullable=True),
'data': fields.JsonField(nullable=True),
'user': fields.StringField(),
'project': fields.StringField(),
'domain': fields.StringField(nullable=True),
'dependents': fields.JsonField(nullable=True),
'profile_name': fields.StringField(nullable=True),
'profile_created_at': fields.StringField(nullable=True),
'tainted': fields.BooleanField(),
}
@staticmethod
def _from_db_object(context, obj, db_obj):
if db_obj is None:
return None
for field in obj.fields:
if field == 'metadata':
obj['metadata'] = db_obj['meta_data']
elif field == 'profile_name':
p = db_obj['profile']
obj['profile_name'] = p.name if p else 'Unknown'
elif field == 'profile_created_at':
p = db_obj['profile']
obj['profile_created_at'] = p.created_at if p else None
elif field == 'tainted':
p = db_obj[field]
obj[field] = p if p else False
else:
obj[field] = db_obj[field]
obj._context = context
obj.obj_reset_changes()
return obj
@classmethod
def create(cls, context, values):
values = cls._transpose_metadata(values)
obj = db_api.node_create(context, values)
# NOTE: We need an extra DB call to make sure the profile is loaded
# and bound to the node created.
obj = db_api.node_get(context, obj.id)
return cls._from_db_object(context, cls(), obj)
@classmethod
def find(cls, context, identity, project_safe=True):
"""Find a node with the given identity.
:param context: An instance of the request context.
:param identity: The UUID, name or short-id of a node.
:param project_safe: A boolean indicating whether only nodes from the
same project as the requesting one are qualified
to be returned.
:return: A DB object of Node.
:raises: An exception of ``ResourceNotFound`` if no matching node is
or an exception of ``MultipleChoices`` more than one node
found matching the criteria.
"""
node = None
if uuidutils.is_uuid_like(identity):
node = cls.get(context, identity, project_safe=project_safe)
if not node:
node = cls.get_by_name(context,
identity,
project_safe=project_safe)
else:
node = cls.get_by_name(context,
identity,
project_safe=project_safe)
if not node:
node = cls.get_by_short_id(context,
identity,
project_safe=project_safe)
if node is None:
raise exception.ResourceNotFound(type='node', id=identity)
return node
@classmethod
def get(cls, context, node_id, **kwargs):
obj = db_api.node_get(context, node_id, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_name(cls, context, name, **kwargs):
obj = db_api.node_get_by_name(context, name, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_short_id(cls, context, short_id, **kwargs):
obj = db_api.node_get_by_short_id(context, short_id, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_all(cls, context, **kwargs):
objs = db_api.node_get_all(context, **kwargs)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def get_all_by_cluster(cls,
context,
cluster_id,
filters=None,
project_safe=True):
objs = db_api.node_get_all_by_cluster(context,
cluster_id,
filters=filters,
project_safe=project_safe)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def ids_by_cluster(cls, context, cluster_id, filters=None):
"""An internal API for retrieving node ids only."""
return db_api.node_ids_by_cluster(context, cluster_id, filters=filters)
@classmethod
def count_by_cluster(cls, context, cluster_id, **kwargs):
return db_api.node_count_by_cluster(context, cluster_id, **kwargs)
@classmethod
def update(cls, context, obj_id, values):
values = cls._transpose_metadata(values)
db_api.node_update(context, obj_id, values)
@classmethod
def migrate(cls, context, obj_id, to_cluster, timestamp, role=None):
return db_api.node_migrate(context,
obj_id,
to_cluster,
timestamp,
role=role)
@classmethod
def delete(cls, context, obj_id):
return db_api.node_delete(context, obj_id)
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'cluster_id': self.cluster_id,
'physical_id': self.physical_id,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'index': self.index,
'role': self.role,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'status': self.status,
'status_reason': self.status_reason,
'data': self.data,
'metadata': self.metadata,
'dependents': self.dependents,
'profile_name': self.profile_name,
'tainted': self.tainted,
}
