class Credential(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin credential object."""
fields = {
'user': fields.StringField(),
'project': fields.StringField(),
'cred': fields.JsonField(),
'data': fields.JsonField(nullable=True),
}
@classmethod
def create(cls, context, values):
obj = db_api.cred_create(context, values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, user, project):
obj = db_api.cred_get(context, user, project)
return cls._from_db_object(context, cls(), obj)
@classmethod
def update(cls, context, user, project, values):
obj = db_api.cred_update(context, user, project, values)
return cls._from_db_object(context, cls(), obj)
@classmethod
def delete(cls, context, user, project):
return db_api.cred_delete(context, user, project)
@classmethod
def update_or_create(cls, context, values):
obj = db_api.cred_create_update(context, values)
return cls._from_db_object(context, cls(), obj)
class ClusterUpdatePolicyRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'policy_id': fields.StringField(),
'enabled': fields.BooleanField(nullable=True, default=True),
}
class TestSenlinObject(obj_base.SenlinObject,
obj_base.VersionedObjectDictCompat):
fields = {
"key1": obj_fields.StringField(),
"key2": obj_fields.StringField(),
"metadata": obj_fields.JsonField()
}
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']
class ActionCreateRequestBody(base.SenlinObject):
fields = {
'name': fields.NameField(),
'cluster_id': fields.StringField(),
'action': fields.StringField(),
'inputs': fields.JsonField(nullable=True, default={}),
}
class NodeOperationRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'operation': fields.StringField(),
'params': fields.JsonField(nullable=True)
}
class ActionUpdateRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'status': fields.StringField(),
'force': fields.BooleanField(default=False)
}
class NodeAdoptPreviewRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'type': fields.StringField(),
'overrides': fields.JsonField(nullable=True),
'snapshot': fields.BooleanField(nullable=True, default=False)
}
class TestPayload(base.NotificationObject):
VERSION = '1.0'
fields = {
'extra_field': fields.StringField(),
'field_1': fields.StringField(),
'field_2': fields.IntegerField(),
}
class ClusterOperationRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'operation': fields.StringField(),
'filters': fields.JsonField(nullable=True, default={}),
'params': fields.JsonField(nullable=True, default={}),
}
class ClusterUpdateRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'name': fields.NameField(nullable=True),
'profile_id': fields.StringField(nullable=True),
'metadata': fields.JsonField(nullable=True),
'timeout': fields.IntegerField(nullable=True),
}
class NodeCreateRequestBody(base.SenlinObject):
fields = {
'cluster_id': fields.StringField(nullable=True, default=''),
'metadata': fields.JsonField(nullable=True, default={}),
'name': fields.NameField(),
'profile_id': fields.StringField(),
'role': fields.fields.StringField(nullable=True, default='')
}
class NodeUpdateRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'metadata': fields.JsonField(nullable=True),
'name': fields.NameField(nullable=True),
'profile_id': fields.StringField(nullable=True),
'role': fields.fields.StringField(nullable=True)
}
class NodePayload(NotificationObject):
VERSION = '1.0'
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(),
'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),
}
@classmethod
def from_node(cls, node):
values = {}
for field in cls.fields:
values[field] = getattr(node, field)
obj = cls(**values)
obj.obj_reset_changes(recursive=False)
return obj
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 NotificationPublisher(base.SenlinObject):
VERSION = '1.0'
fields = {
'host': fields.StringField(nullable=False),
'binary': fields.StringField(nullable=False),
}
@classmethod
def from_service_obj(cls, service):
return cls(host=service.host, binary=service.binary)
class Policy(base.SenlinObject, base.VersionedObjectDictCompat):
"""Senlin policy object."""
fields = {
'id': fields.UUIDField(),
'name': fields.StringField(),
'type': fields.StringField(),
'spec': fields.JsonField(),
'cooldown': fields.IntegerField(nullable=True),
'level': fields.IntegerField(nullable=True),
'data': fields.JsonField(nullable=True),
'created_at': fields.DateTimeField(),
'updated_at': fields.DateTimeField(nullable=True),
'user': fields.StringField(),
'project': fields.StringField(),
'domain': fields.StringField(nullable=True),
}
@classmethod
def create(cls, context, values):
obj = db_api.policy_create(context, values)
return cls._from_db_object(context, cls(context), obj)
@classmethod
def get(cls, context, policy_id, **kwargs):
obj = db_api.policy_get(context, policy_id, **kwargs)
return cls._from_db_object(context, cls(), obj)
@classmethod
def get_by_name(cls, context, name, **kwargs):
obj = db_api.policy_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.policy_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.policy_get_all(context, **kwargs)
return [cls._from_db_object(context, cls(), obj) for obj in objs]
@classmethod
def update(cls, context, obj_id, values):
obj = db_api.policy_update(context, obj_id, values)
return cls._from_db_object(context, cls(), obj)
@classmethod
def delete(cls, context, obj_id):
db_api.policy_delete(context, obj_id)
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 NotificationPublisher(NotificationObject):
VERSION = '1.0'
fields = {
'host': fields.StringField(),
'binary': fields.StringField(),
}
@classmethod
def from_service(cls, service):
return cls(host=service.host, binary=service.binary)
@property
def publisher_id(self):
return '%s:%s' % (self.binary, self.host)
class EventType(NotificationObject):
VERSION = '1.0'
fields = {
'object': fields.StringField(nullable=False),
'action': fields.StringField(nullable=False),
'phase': fields.NotificationPhaseField(nullable=True),
}
def to_notification_field(self):
"""Serialize the object to the wire format."""
s = '%s.%s' % (self.object, self.action)
if self.obj_attr_is_set('phase'):
s += '.%s' % self.phase
return s
class ClusterCreateRequestBody(base.SenlinObject):
fields = {
'name':
fields.NameField(),
'profile_id':
fields.StringField(),
'min_size':
fields.CapacityField(nullable=True,
minimum=0,
default=consts.CLUSTER_DEFAULT_MIN_SIZE),
'max_size':
fields.CapacityField(nullable=True,
minimum=-1,
default=consts.CLUSTER_DEFAULT_MAX_SIZE),
'desired_capacity':
fields.CapacityField(nullable=True,
minimum=0,
default=consts.CLUSTER_DEFAULT_MIN_SIZE),
'metadata':
fields.JsonField(nullable=True, default={}),
'timeout':
fields.NonNegativeIntegerField(nullable=True,
default=CONF.default_action_timeout),
}
class TestObject(vo_base.SenlinObject):
VERSION = '1.0'
fields = {
'field_1': fields.StringField(),
'field_2': fields.IntegerField(),
'not_important_field': fields.IntegerField(),
}
class ClusterScaleOutRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'count': fields.NonNegativeIntegerField(nullable=True),
'health_check': fields.BooleanField(nullable=True, default=False)
}
class NodeGetRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'show_details': fields.FlexibleBooleanField(nullable=True,
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(),
}
@classmethod
def create(cls, context, cluster_id, check_type, interval, params,
engine_id):
obj = db_api.registry_create(context, cluster_id, check_type,
interval, params, engine_id)
return cls._from_db_object(context, cls(context), obj)
@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)
class TestPayload(notification.NotificationPayloadBase):
VERSION = '1.0'
schema = {
'field_1': ('source_field', 'field_1'),
'field_2': ('source_field', 'field_2'),
}
fields = {
'extra_field': fields.StringField(), # filled by ctor
'field_1': fields.StringField(), # filled by the schema
'field_2': fields.IntegerField(), # filled by the schema
}
def populate_schema(self, source_field):
super(TestPayload, self).populate_schema(source_field=source_field)
class ClusterCreateRequestBody(base.SenlinObject):
# VERSION 1.0: initial version
# VERSION 1.1: added field 'config'
VERSION = '1.1'
VERSION_MAP = {
'1.7': '1.1',
}
fields = {
'name': fields.NameField(),
'profile_id': fields.StringField(),
'min_size': fields.CapacityField(
nullable=True, minimum=0,
default=consts.CLUSTER_DEFAULT_MIN_SIZE),
'max_size': fields.CapacityField(
nullable=True, minimum=-1,
default=consts.CLUSTER_DEFAULT_MAX_SIZE),
'desired_capacity': fields.CapacityField(
nullable=True, minimum=0),
'metadata': fields.JsonField(nullable=True, default={}),
'timeout': fields.NonNegativeIntegerField(
nullable=True, default=CONF.default_action_timeout),
'config': fields.JsonField(nullable=True, default={}),
}
def obj_make_compatible(self, primitive, target_version):
super(ClusterCreateRequest, self).obj_make_compatible(
primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
if 'config' in primitive['senlin_object.data']:
del primitive['senlin_object.data']['config']
class ReceiverUpdateRequest(base.SenlinObject):
fields = {
'identity': fields.StringField(),
'name': fields.NameField(nullable=True),
'action': fields.ClusterActionNameField(nullable=True),
'params': fields.JsonField(nullable=True, default={})
}
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 ReceiverCreateRequestBody(base.SenlinObject):
fields = {
'name': fields.NameField(),
'type': fields.ReceiverTypeField(),
'cluster_id': fields.StringField(nullable=True),
'action': fields.ClusterActionNameField(nullable=True),
'actor': fields.JsonField(nullable=True, default={}),
'params': fields.JsonField(nullable=True, default={})
}
