class Broker(base.CueObject):
dbapi = db_api.get_instance()
fields = {
'id': obj_utils.str_or_none,
'name': obj_utils.str_or_none,
'active': obj_utils.bool_or_none,
'deleted': obj_utils.bool_or_none,
'created_at': obj_utils.datetime_or_str_or_none,
'updated_at': obj_utils.datetime_or_str_or_none,
'deleted_at': obj_utils.datetime_or_str_or_none,
}
@staticmethod
def _from_db_object(broker, db_broker):
"""Convert a database object to a universal broker object."""
for field in broker.fields:
broker[field] = db_broker[field]
return broker
def create_broker(self, context):
"""Creates a new broker.
:param context: request context object
"""
broker_values = self.as_dict()
db_broker = self.dbapi.create_broker(context, broker_values)
return self._from_db_object(self, db_broker)
def delete_broker(self, context):
"""Deletes a Broker object for specified broker_id.
:param context: request context object
"""
self.dbapi.delete_broker(context, self.id)
def update_broker(self, context):
"""Updates a Broker type/status for specified broker_id.
:param context: request context object
"""
broker_value = self.as_dict()
self.dbapi.update_broker(context, self.id, broker_value)
@classmethod
def get_brokers(cls, context):
"""Returns a list of Broker objects.
:param context: request context object
:returns: a list of :class:'Broker' object
"""
db_brokers = cls.dbapi.get_brokers(context)
return [Broker._from_db_object(Broker(), obj) for obj in db_brokers]
class Node(base.CueObject):
dbapi = db_api.get_instance()
fields = {
'id': obj_utils.str_or_none,
'cluster_id': obj_utils.str_or_none,
'instance_id': obj_utils.str_or_none,
'flavor': obj_utils.str_or_none,
'management_ip': obj_utils.str_or_none,
'status': obj_utils.str_or_none,
'created_at': obj_utils.datetime_or_str_or_none,
'updated_at': obj_utils.datetime_or_str_or_none,
'deleted_at': obj_utils.datetime_or_str_or_none,
}
@staticmethod
def _from_db_object(node, db_node):
"""Convert a database object to a universal node object."""
for field in node.fields:
node[field] = db_node[field]
return node
def update(self, context, node_id):
"""Updates a database node object.
:param context: The request context
:param node_id:
"""
node_changes = self.obj_get_changes()
self.dbapi.update_node(context, node_changes, node_id)
@classmethod
def get_nodes_by_cluster_id(cls, context, cluster_id):
"""Returns a list of Node objects for specified cluster.
:param context: request context object
:param cluster_id: UUID of the cluster
:returns: a list of :class:'Node' object
"""
db_nodes = cls.dbapi.get_nodes_in_cluster(context, cluster_id)
return [Node._from_db_object(Node(), obj) for obj in db_nodes]
@classmethod
def get_node_by_id(cls, context, node_id):
"""Returns a Node specified by it's id.
:param context: request context object
:param node_id: UUID of a node
"""
db_node = cls.dbapi.get_node_by_id(context, node_id)
return Node._from_db_object(Node(), db_node)
class Endpoint(base.CueObject):
dbapi = db_api.get_instance()
fields = {
'id': obj_utils.str_or_none,
'node_id': obj_utils.str_or_none,
'uri': obj_utils.str_or_none,
'type': obj_utils.str_or_none,
}
@staticmethod
def _from_db_object(cluster, db_cluster):
"""Convert a database object to a universal endpoint object."""
for field in cluster.fields:
cluster[field] = db_cluster[field]
return cluster
def create(self, context):
"""Creates a new endpoint.
:param context: The request context
"""
endpoint_changes = self.obj_get_changes()
db_endpoint = self.dbapi.create_endpoint(context, endpoint_changes)
self._from_db_object(self, db_endpoint)
@classmethod
def update_by_node_id(cls, context, node_id, endpoint_changes):
"""Updates a database endpoint object.
:param context: The request context
:param node_id: The node id
:param endpoint_changes: dictionary of endpoint changes
"""
cls.dbapi.update_endpoints_by_node_id(context, endpoint_changes,
node_id)
@classmethod
def get_endpoints_by_node_id(cls, context, node_id):
"""Returns a list of Endpoint objects for specified node.
:param node_id: UUID of the node.
:returns: a list of :class:'Endpoint' object.
"""
db_endpoints = cls.dbapi.get_endpoints_in_node(context, node_id)
return [
Endpoint._from_db_object(Endpoint(), obj) for obj in db_endpoints
]
class NodeObjectsTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def validate_node_values(self, node_ref, node_cmp):
"""Validate Node Object fields."""
self.assertEqual(node_ref.id if hasattr(node_ref, "id") else
node_ref["id"],
node_cmp.id if hasattr(node_cmp, "id") else
node_cmp["id"],
"Invalid node id value")
self.assertEqual(node_ref.cluster_id if hasattr(node_ref, "cluster_id")
else node_ref["cluster_id"],
node_cmp.cluster_id if hasattr(node_cmp, "cluster_id")
else node_cmp["cluster_id"],
"Invalid cluster_id value")
self.assertEqual(node_ref.instance_id if hasattr(node_ref,
"instance_id") else node_ref["instance_id"],
node_cmp.instance_id if hasattr(node_cmp,
"instance_id") else node_cmp["instance_id"],
"Invalid instance_id value")
self.assertEqual(node_ref.flavor if hasattr(node_ref, "flavor") else
node_ref["flavor"],
node_cmp.flavor if hasattr(node_cmp, "flavor") else
node_cmp["flavor"],
"Invalid flavor value")
self.assertEqual(node_ref.status if hasattr(node_ref, "status") else
node_ref["status"],
node_cmp.status if hasattr(node_cmp, "status") else
node_cmp["status"],
"Invalid status value")
self.assertEqual(node_ref.management_ip if hasattr(
node_ref, "management_ip") else
node_ref["management_ip"],
node_cmp.management_ip if hasattr(
node_cmp, "management_ip") else
node_cmp["management_ip"],
"Invalid management ip value")
self.assertTrue(test_utils.compare_dates(node_ref["created_at"],
node_cmp["created_at"]),
"Invalid created_at value")
self.assertTrue(test_utils.compare_dates(node_ref["updated_at"],
node_cmp["updated_at"]),
"Invalid updated_at value")
self.assertTrue(test_utils.compare_dates(node_ref["deleted_at"],
node_cmp["deleted_at"]),
"Invalid deleted_at value")
def test_node_object_generation(self):
"""Test Node Object generation from a node dictionary object."""
node_dict = func_utils.get_test_node_dict()
node_object = objects.Node(**node_dict)
self.validate_node_values(node_object, node_dict)
def test_node_db_to_object_to_db(self):
"""Tests Node db object conversion to Node object and back
to db object.
"""
node_dict = func_utils.get_test_node_dict()
db_node_object = models.Node()
db_node_object.update(node_dict)
object_node = objects.Node._from_db_object(objects.Node(),
db_node_object)
self.validate_node_values(db_node_object, object_node)
node_changes = object_node.obj_get_changes()
db_node_object_2 = models.Endpoint()
db_node_object_2.update(node_changes)
self.validate_node_values(db_node_object, db_node_object_2)
def test_update_node_size_one(self):
"""Tests update node from Node objects API."""
new_cluster = func_utils.create_object_cluster(self.context, size=1,
flavor='flavor1')
db_node = self.dbapi.get_nodes_in_cluster(self.context, new_cluster.id)
new_node = objects.Node._from_db_object(objects.Node(), db_node[0])
new_node.flavor = 'flavor2'
new_node.update(self.context, new_node.id)
updated_node = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)[0]
self.assertEqual('flavor2', updated_node.flavor)
def test_update_node_size_three(self):
"""Tests update three nodes from Node objects API."""
new_cluster = func_utils.create_object_cluster(self.context, size=3,
flavor='flavor1')
db_nodes = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)
# check if cluster size is 3
self.assertEqual(3, len(db_nodes))
for current_node in db_nodes:
current_node = objects.Node._from_db_object(objects.Node(),
current_node)
current_node.flavor = 'flavor2'
current_node.update(self.context, current_node.id)
updated_nodes = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)
for nodes in updated_nodes:
self.assertEqual('flavor2', nodes.flavor)
def test_get_nodes_by_cluster_id(self):
"""Tests get nodes by cluster id from Node objects API."""
new_cluster = func_utils.create_object_cluster(self.context, size=2)
db_nodes = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)
node_list = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
for db_node, node in zip(db_nodes, node_list):
self.validate_node_values(db_node, node)
def test_get_node_by_id(self):
"""Tests get nodes by node id from Nodes objects API."""
new_cluster = func_utils.create_object_cluster(self.context)
db_node = self.dbapi.get_nodes_in_cluster(self.context, new_cluster.id)
obj_node = objects.Node._from_db_object(objects.Node(), db_node[0])
node = objects.Node.get_node_by_id(self.context, obj_node.id)
self.validate_node_values(obj_node, node)
class ApiTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def setUp(self):
super(ApiTests, self).setUp()
# Delete any default brokers and broker metadata
brokers = self.dbapi.get_brokers(self.context)
for broker in brokers:
broker_metadata_list = self.dbapi.get_broker_metadata_by_broker_id(
self.context, broker.id)
for broker_metadata in broker_metadata_list:
self.dbapi.delete_broker_metadata(self.context,
broker_metadata.id)
self.dbapi.delete_broker(self.context, broker.id)
# Add a default broker & metadata specific to this test class
broker_values = {'name': 'fake broker', 'active': '1'}
broker = self.dbapi.create_broker(self.context, broker_values)
broker_metadata_values = {
'key': 'IMAGE',
'value': 'f7e8c49b-7d1e-472f-a78b-7c46a39c85be',
'broker_id': broker.id
}
self.dbapi.create_broker_metadata(self.context, broker_metadata_values)
def test_get_clusters(self):
"""Verifies get clusters DB API."""
def test_create_clusters(self):
"""Verifies create cluster DB API."""
cluster_values = {
"project_id": UUID1,
"name": "Rabbit Cluster",
"network_id": UUID2,
"flavor": "medium",
"size": 5,
"volume_size": 250,
}
db_cluster = self.dbapi.create_cluster(self.context, cluster_values)
self.assertEqual(cluster_values["name"], db_cluster.name,
"invalid name value")
self.assertEqual(cluster_values["network_id"], db_cluster.network_id,
"invalid network_id value")
self.assertEqual(cluster_values["flavor"], db_cluster.flavor,
"invalid flavor value")
self.assertEqual(cluster_values["size"], db_cluster.size,
"invalid size value")
self.assertEqual(cluster_values["volume_size"], db_cluster.volume_size,
"invalid volume_size value")
self.assertFalse(db_cluster.deleted, "invalid deleted value")
def test_get_cluster_by_id(self):
"""Verifies create cluster DB API."""
def test_get_nodes_in_cluster(self):
"""Verifies create cluster DB API."""
cluster_values = {
"project_id": UUID1,
"name": "Rabbit Cluster",
"network_id": UUID2,
"flavor": "medium",
"size": 5,
"volume_size": 250,
}
db_cluster = self.dbapi.create_cluster(self.context, cluster_values)
db_nodes = self.dbapi.get_nodes_in_cluster(self.context, db_cluster.id)
for node in db_nodes:
self.assertEqual(db_cluster.id, node.cluster_id,
"invalid flavor value")
self.assertEqual(cluster_values["flavor"], node.flavor,
"invalid flavor value")
self.assertFalse(node.deleted, "invalid deleted value")
def test_get_endpoints_in_node(self):
"""Verifies create cluster DB API."""
def test_update_cluster_deleting(self):
"""Verifies create cluster DB API."""
def test_create_broker(self):
"""Verifies create broker DB API."""
broker_values = {"name": "Test Broker Name", "active": 1}
db_broker = self.dbapi.create_broker(self.context, broker_values)
self.assertEqual(broker_values['name'], db_broker.name,
"invalid broker name value")
self.assertEqual(broker_values['active'], db_broker.active,
"invalid broker active value")
def test_get_default_broker(self):
"""Verifies get brokers DB API."""
brokers = self.dbapi.get_brokers(self.context)
self.assertIsNotNone(brokers,
"Should have found the default RabbitMQ broker.")
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
self.assertEqual(
brokers[0].name, "fake broker",
"Should have found the default fake broker, "
"instead found: " + str(brokers[0].name))
def test_get_multiple_brokers(self):
"""Verifies get brokers DB API."""
self.dbapi.create_broker(self.context, {
"name": "Test Broker Name 1",
"active": 1
})
self.dbapi.create_broker(self.context, {
"name": "Test Broker Name 2",
"active": 1
})
brokers = self.dbapi.get_brokers(self.context)
self.assertIsNotNone(brokers,
"Should have found the default RabbitMQ broker.")
self.assertIs(
len(brokers), 3,
"Should have found 3 brokers, instead found " + str(len(brokers)))
def test_delete_broker(self):
"""Verifies delete broker DB API."""
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
broker_id = brokers[0].id
self.dbapi.delete_broker(self.context, broker_id)
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 0, "Should have found 0 brokers after deleting the "
"default broker. Instead found " + str(len(brokers)))
broker_query = sqlalchemy_api.model_query(
self.context, models.Broker,
read_deleted=True).filter_by(id=broker_id)
broker = broker_query.one()
self.assertEqual(broker_id, broker.id,
"Query should have returned the same broker.")
self.assertTrue(broker.deleted, "Broker deleted flag should be true.")
def test_update_broker(self):
"""Verifies update broker DB API."""
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
broker_id = brokers[0].id
self.assertEqual(
brokers[0].name, "fake broker",
"Should have found the default fake broker. "
"Instead found: " + brokers[0].name)
broker_values = {"name": "Test Broker Name", "active": 1}
self.dbapi.update_broker(self.context, broker_id, broker_values)
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
self.assertEqual(
brokers[0].name, "Test Broker Name",
"Should have found the default rabbitmq broker. "
"Instead found: " + brokers[0].name)
def test_create_broker_metadata(self):
"""Verifies create broker metadata DB API."""
broker_values = {"name": "Test Broker Name", "active": 1}
db_broker = self.dbapi.create_broker(self.context, broker_values)
broker_metadata_values = {
"broker_id": db_broker.id,
"key": "IMAGE",
"value": "test_image"
}
db_broker = self.dbapi.create_broker_metadata(self.context,
broker_metadata_values)
self.assertEqual(broker_metadata_values['broker_id'],
db_broker.broker_id, "invalid broker_metadata ID")
self.assertEqual(broker_metadata_values['key'], db_broker.key,
"invalid broker key")
self.assertEqual(broker_metadata_values['value'], db_broker.value,
"invalid broker value")
def test_create_broker_metadata_missing_broker(self):
"""Testing create metadata with broker ID that should not exist."""
broker_metadata_values = {
"broker_id": UUID1,
"key": "IMAGE",
"value": "test_image"
}
try:
self.assertRaises(exception.NotFound,
self.dbapi.create_broker_metadata, self.context,
broker_metadata_values)
except Exception as err:
self.assertIsNotNone(
None, "Unhandled exception from "
"create_broker_metadata with UUI that isn't "
"in the broker table: " + str(err))
# Testing with non-UUID formatted ID
broker_metadata_values['broker_id'] = "Not a UUID"
try:
self.assertRaises(exception.Invalid,
self.dbapi.create_broker_metadata, self.context,
broker_metadata_values)
except Exception as err:
self.assertIsNotNone(
None, "Unhandled exception from "
"create_broker_metadata with invalid UUID: " + str(err))
def test_get_broker_metadata_by_broker_id(self):
"""Verifies get broker metadata by broker id DB API."""
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
broker_id = brokers[0].id
broker_metadata = self.dbapi.get_broker_metadata_by_broker_id(
self.context, broker_id)
self.assertIs(len(broker_metadata), 1,
"Should have found the default rabbitmq broker ID.")
# TODO(team) May want to have all cue.db.sqlalchemy.api.Connection
# TODO(team) functions that take a broker_id assert it is of type UUID
self.assertRaises(oslo_exception.DBError,
self.dbapi.get_broker_metadata_by_broker_id,
self.context, "Bad ID")
def test_delete_broker_metadata(self):
"""Verifies delete broker metadata DB API."""
brokers = self.dbapi.get_brokers(self.context)
self.assertIs(
len(brokers), 1,
"Should have found only 1 broker, instead found " +
str(len(brokers)))
broker_id = brokers[0].id
broker_metadata = self.dbapi.get_broker_metadata_by_broker_id(
self.context, broker_id)
broker_metadata_id = broker_metadata[0].id
self.dbapi.delete_broker_metadata(self.context, broker_metadata_id)
broker_metadata = self.dbapi.get_broker_metadata_by_broker_id(
self.context, broker_id)
self.assertIs(0, len(broker_metadata), "Broker metadata should be "
"empty after the delete.")
broker_metadata_query = sqlalchemy_api.model_query(
self.context, models.BrokerMetadata,
read_deleted=True).filter_by(id=broker_metadata_id)
broker_metadata = broker_metadata_query.one()
self.assertEqual(
broker_metadata_id, broker_metadata.id,
"Query should have returned the same broker " + "metadata.")
self.assertTrue(broker_metadata.deleted,
"Broker metadata deleted flag should be true.")
def test_get_image_id_by_broker_name(self):
default_metadata_id = "f7e8c49b-7d1e-472f-a78b-7c46a39c85be"
image_id = self.dbapi.get_image_id_by_broker_name(
self.context, 'fake broker')
self.assertEqual(
default_metadata_id, image_id,
"Should have found the image ID of the default rabbitmq"
" broker.")
def test_get_image_id_by_broker_name_with_missing_broker(self):
self.assertRaises(exception.NotFound,
self.dbapi.get_image_id_by_broker_name, self.context,
"fake mq")
class BrokerMetadata(base.CueObject):
dbapi = db_api.get_instance()
fields = {
'id': obj_utils.str_or_none,
'broker_id': obj_utils.str_or_none,
'key': obj_utils.str_or_none,
'value': obj_utils.str_or_none,
'deleted': obj_utils.bool_or_none,
'created_at': obj_utils.datetime_or_str_or_none,
'updated_at': obj_utils.datetime_or_str_or_none,
'deleted_at': obj_utils.datetime_or_str_or_none,
}
@staticmethod
def _from_db_object(broker_metadata, db_broker_metadata):
"""Convert a database object to a universal brokerMetadata object."""
for field in BrokerMetadata.fields:
broker_metadata[field] = db_broker_metadata[field]
return broker_metadata
def create_broker_metadata(self, context):
"""Creates a new broker metadata.
:param context: request context object
"""
metadata_values = self.as_dict()
db_broker = self.dbapi.create_broker_metadata(context, metadata_values)
self._from_db_object(self, db_broker)
def delete_broker_metadata(self, context):
"""Deletes a BrokerMetadata object for specified broker_id.
:param context: request context object
"""
self.dbapi.delete_broker_metadata(context, self.id)
@classmethod
def get_broker_metadata_by_broker_id(cls, context, broker_id):
"""Returns a list of BrokerMetadata objects for specified broker_id.
:param context: request context object
:param broker_id: broker id
:returns: a list of :class:'BrokerMetadata' object
"""
db_broker_metadata = cls.dbapi.get_broker_metadata_by_broker_id(
context, broker_id)
return [BrokerMetadata._from_db_object(BrokerMetadata(), obj)
for obj in db_broker_metadata]
@classmethod
def get_image_id_by_broker_name(cls, context, broker_name):
"""Returns a image_id for the broker
:param context: request context object
:param: broker name
"""
image_id = cls.dbapi.get_image_id_by_broker_name(context, broker_name)
return image_id
class BrokerObjectsTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def create_object_broker(self, **kw):
"""Create a broker object."""
test_broker_dict = func_utils.get_test_broker_dict(**kw)
new_broker = objects.Broker(**test_broker_dict)
self.validate_broker_values(test_broker_dict, new_broker)
new_broker.create_broker(self.context)
# retrieve created broker
broker_query = sqlalchemy_api.model_query(
self.context, models.Broker).filter_by(id=test_broker_dict['id'])
db_broker = broker_query.one()
broker_obj = objects.Broker._from_db_object(objects.Broker(),
db_broker)
return broker_obj
def validate_broker_values(self, broker_ref, broker_cmp):
"""Validate Broker Object fields."""
self.assertEqual(
broker_ref.id if hasattr(broker_ref, "id") else broker_ref["id"],
broker_cmp.id if hasattr(broker_cmp, "id") else broker_cmp["id"],
"Invalid broker id value")
self.assertEqual(
broker_ref.name if hasattr(
broker_ref, "name") else broker_ref["name"], broker_cmp.name
if hasattr(broker_cmp, "name") else broker_cmp["name"],
"Invalid name value")
self.assertEqual(
broker_ref.active if hasattr(broker_ref, "active") else
broker_ref["active"], broker_cmp.active if hasattr(
broker_cmp, "active") else broker_cmp["active"],
"Invalid active status")
self.assertTrue(
test_utils.compare_dates(broker_ref["created_at"],
broker_cmp["created_at"]),
"Invalid created_at value")
self.assertTrue(
test_utils.compare_dates(broker_ref["updated_at"],
broker_cmp["updated_at"]),
"Invalid updated_at value")
self.assertTrue(
test_utils.compare_dates(broker_ref["deleted_at"],
broker_cmp["deleted_at"]),
"Invalid deleted_at value")
def test_broker_object_generation(self):
"""Test Broker Object generation from a broker dictionary object."""
broker_dict = func_utils.get_test_broker_dict()
broker_object = objects.Broker(**broker_dict)
self.validate_broker_values(broker_dict, broker_object)
def test_broker_db_to_object_to_db(self):
"""Tests Broker db object conversion to Broker object and back
to db object.
"""
broker_dict = func_utils.get_test_broker_dict()
db_broker_object = models.Broker()
db_broker_object.update(broker_dict)
object_broker = objects.Broker._from_db_object(objects.Broker(),
db_broker_object)
self.validate_broker_values(db_broker_object, object_broker)
broker_changes = object_broker.obj_get_changes()
db_broker_object_2 = models.Broker()
db_broker_object_2.update(broker_changes)
self.validate_broker_values(db_broker_object, db_broker_object_2)
def test_create_broker(self):
"""Tests create broker from Broker objects API."""
test_broker_dict = func_utils.get_test_broker_dict()
new_broker = objects.Broker(**test_broker_dict)
self.validate_broker_values(new_broker, test_broker_dict)
retrieved_broker = new_broker.create_broker(self.context)
self.validate_broker_values(new_broker, retrieved_broker)
def test_update_broker(self):
"""Tests update broker from Broker objects API."""
new_broker = self.create_object_broker()
new_broker.name = 'rabbit1.0'
new_broker.active = False
new_broker.update_broker(self.context)
# retrieve updated broker
broker_query = sqlalchemy_api.model_query(
self.context, models.Broker).filter_by(id=new_broker.id)
updated_broker = broker_query.one()
self.assertEqual('rabbit1.0', updated_broker.name)
self.assertFalse(updated_broker.active)
def test_get_brokers(self):
"""Tests getting all brokers from Broker objects API."""
# delete existing default broker
existing_broker = objects.Broker.get_brokers(self.context)
existing_broker[0].delete_broker(self.context)
# create new brokers
new_broker_1 = self.create_object_broker(
id='0e8e643e-eeb9-11e4-90ec-1681e6b88ec1', name='rabbit1.0')
new_broker_2 = self.create_object_broker(
id='ea1c6010-eeb8-11e4-90ec-1681e6b88ec1', name='rabbit2.0')
broker_list = objects.Broker.get_brokers(self.context)
# check for the list length
self.assertEqual(2, len(broker_list), "Invalid number of brokers "
"returned")
for broker in broker_list:
if broker.id == new_broker_1.id:
self.validate_broker_values(new_broker_1, broker)
else:
self.validate_broker_values(new_broker_2, broker)
def test_delete_broker(self):
"""Tests delete from Broker objects API."""
new_broker = self.create_object_broker()
new_broker.delete_broker(self.context)
# try to retrieve deleted broker
broker_query = sqlalchemy_api.model_query(
self.context, models.Broker).filter_by(id=new_broker.id)
self.assertRaises(sql_exception.NoResultFound, broker_query.one)
class ClusterObjectsTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def validate_cluster_deleted_fields(self, cluster_ref, cluster_cmp):
"""Validate Cluster Object deleted and deleted_at fields."""
self.assertEqual(cluster_ref.deleted, cluster_cmp.deleted,
"Invalid cluster deleted value")
self.assertTrue(
test_utils.compare_dates(
cluster_ref.deleted_at if hasattr(
cluster_ref, "deleted_at") else cluster_ref["deleted_at"],
cluster_cmp.deleted_at if hasattr(
cluster_cmp, "deleted_at") else cluster_cmp["deleted_at"]),
"Invalid cluster deleted_at value")
def test_cluster_object_generation(self):
"""Test Cluster Object generation from a cluster dictionary object."""
cluster_dict = func_utils.get_test_cluster()
cluster_object = objects.Cluster(**cluster_dict)
test_utils.validate_cluster_values(self, cluster_dict, cluster_object)
def test_cluster_api_to_object_to_api(self):
"""Tests Cluster api object conversion to Cluster object and back
to api object.
"""
# create cluster api object
api_cluster = func_utils.create_api_test_cluster_all().as_dict()
# adjust network_id from list to single value
api_cluster['network_id'] = api_cluster['network_id'][0]
# create cue cluster object from api cluster object
object_cluster = objects.Cluster(**api_cluster).as_dict()
# verify fields match
test_utils.validate_cluster_values(self, api_cluster, object_cluster)
# adjust network_id from single value back to list
object_cluster['network_id'] = [object_cluster['network_id']]
# create cluster api object from cue cluster object
api_cluster_2 = cluster.Cluster(**object_cluster).as_dict()
# verify fields match to initial api cluster object
test_utils.validate_cluster_values(self, api_cluster, api_cluster_2)
def test_cluster_db_to_object_to_db(self):
"""Tests Cluster db object conversion to Cluster object and back
to db object.
"""
db_cluster_object = func_utils.create_db_test_cluster_model_object(
self.context, deleted_at=timeutils.utcnow(), deleted=True)
object_cluster = objects.Cluster._from_db_object(
objects.Cluster(), db_cluster_object)
test_utils.validate_cluster_values(self, db_cluster_object,
object_cluster)
self.validate_cluster_deleted_fields(db_cluster_object, object_cluster)
cluster_changes = object_cluster.obj_get_changes()
db_cluster_object_2 = models.Cluster()
db_cluster_object_2.update(cluster_changes)
test_utils.validate_cluster_values(self, db_cluster_object,
db_cluster_object_2)
self.validate_cluster_deleted_fields(db_cluster_object,
db_cluster_object_2)
def test_create_cluster_size_one(self):
"""Tests create cluster from Cluster objects API."""
test_cluster_dict = func_utils.get_test_cluster(size=1)
new_cluster = objects.Cluster(**test_cluster_dict)
test_utils.validate_cluster_values(self, test_cluster_dict,
new_cluster)
new_cluster.create(self.context)
db_cluster = self.dbapi.get_cluster_by_id(self.context, new_cluster.id)
test_utils.validate_cluster_values(self, new_cluster, db_cluster)
cluster_node = self.dbapi.get_nodes_in_cluster(self.context,
db_cluster.id)
# check if cluster size is one before accessing the node
self.assertEqual(1, len(cluster_node))
self.assertEqual(db_cluster.id, cluster_node[0].cluster_id)
self.assertEqual(db_cluster.flavor, cluster_node[0].flavor)
self.assertEqual(db_cluster.status, cluster_node[0].status)
def test_create_cluster_size_three(self):
"""Tests create cluster of size three from Cluster objects API."""
test_cluster_dict = func_utils.get_test_cluster(size=3)
new_cluster = objects.Cluster(**test_cluster_dict)
test_utils.validate_cluster_values(self, test_cluster_dict,
new_cluster)
new_cluster.create(self.context)
db_cluster = self.dbapi.get_cluster_by_id(self.context, new_cluster.id)
test_utils.validate_cluster_values(self, new_cluster, db_cluster)
cluster_nodes = self.dbapi.get_nodes_in_cluster(
self.context, db_cluster.id)
for nodes in cluster_nodes:
self.assertEqual(db_cluster.id, nodes.cluster_id)
self.assertEqual(db_cluster.flavor, nodes.flavor)
self.assertEqual(db_cluster.status, nodes.status)
def test_update_cluster(self):
"""Tests update cluster from Cluster objects API."""
new_cluster = func_utils.create_object_cluster(self.context,
name='test_cluster',
flavor='flavor1')
new_cluster.flavor = 'flavor2'
new_cluster.name = 'test_cluster1'
new_cluster.update(self.context, new_cluster.id)
updated_cluster = self.dbapi.get_cluster_by_id(self.context,
new_cluster.id)
# check update fields
self.assertEqual('flavor2', updated_cluster.flavor)
self.assertEqual('test_cluster1', updated_cluster.name)
# check unchanged fields fields
self.assertEqual(new_cluster.id, updated_cluster.id)
self.assertEqual(new_cluster.network_id, updated_cluster.network_id)
self.assertEqual(new_cluster.status, updated_cluster.status)
self.assertEqual(new_cluster.size, updated_cluster.size)
def test_get_cluster_list_size_one(self):
"""Tests list Cluster of size one from Cluster objects API."""
new_cluster = func_utils.create_object_cluster(self.context)
cluster_list = objects.Cluster.get_clusters(self.context)
test_utils.validate_cluster_values(self, cluster_list[0], new_cluster)
def test_get_cluster_list_size_three(self):
"""Tests list Clusters of size three from Cluster objects API."""
cluster_list = list()
for list_size in range(3):
new_cluster = func_utils.create_object_cluster(self.context,
id=str(
uuid.uuid4()))
cluster_list.append(new_cluster)
returned_cluster_list = objects.Cluster.get_clusters(self.context)
for returned_clusterobj, clusterobj in zip(returned_cluster_list,
cluster_list):
test_utils.validate_cluster_values(self, returned_clusterobj,
clusterobj)
def test_get_cluster_by_id(self):
"""Tests get Cluster by id from Cluster objects API."""
new_cluster = func_utils.create_object_cluster(self.context)
test_cluster = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
test_utils.validate_cluster_values(self, new_cluster, test_cluster)
def test_get_nonexistent_cluster(self):
"""Tests get cluster from Cluster objects API for nonexistent cluster.
"""
func_utils.create_object_cluster(self.context)
nonexistent_cluster_id = '17efe8ae-e93c-11e4-b02c-1681e6b88ec1'
self.assertRaises(exception.NotFound,
objects.Cluster.get_cluster_by_id, self.context,
nonexistent_cluster_id)
def test_update_cluster_deleting(self):
"""Tests delete from Cluster objects API."""
new_cluster = func_utils.create_object_cluster(self.context)
objects.Cluster.update_cluster_deleting(self.context, new_cluster.id)
deleted_cluster = self.dbapi.get_cluster_by_id(self.context,
new_cluster.id)
self.assertEqual('DELETING', deleted_cluster.status)
def test_update_cluster_deleting_invalid_id(self):
"""Tests delete from Cluster objects API with invalid cluster id."""
func_utils.create_object_cluster(self.context)
invalid_cluster_id = '17efe8ae-e93c-11e4-b02c-1681e6b88ec1'
self.assertRaises(exception.NotFound,
objects.Cluster.update_cluster_deleting,
self.context, invalid_cluster_id)
def test_get_cluster_by_id_forbidden(self):
"""Tests get Cluster by id with invalid tenant."""
api_cluster = func_utils.create_object_cluster(self.context)
tenant_b = self.get_context(tenant='b')
with mock.patch.object(objects.Cluster.dbapi,
'get_cluster_by_id',
return_value=api_cluster):
with testtools.ExpectedException(exception.NotAuthorized):
cluster.get_complete_cluster(tenant_b, api_cluster.id)
def test_update_cluster_deleting_forbidden(self):
"""Tests delete from Cluster objects API with invalid tenant."""
api_cluster = func_utils.create_object_cluster(self.context)
tenant_b = self.get_context(tenant='b')
with mock.patch.object(objects.Cluster.dbapi,
'get_cluster_by_id',
return_value=api_cluster):
with testtools.ExpectedException(exception.NotAuthorized):
cluster.delete_complete_cluster(tenant_b, api_cluster.id)
def before(self, state):
state.request.dbapi = dbapi.get_instance()
def test_create_cluster_model(self):
"""Verifies a new cluster record is created in DB."""
cluster_values = {
"id": UUID1,
"network_id": UUID3,
"project_id": self.context.project_id,
"name": "Cluster test",
"status": models.Status.BUILDING,
"flavor": "medium",
"size": 3,
"volume_size": 250,
"deleted": False,
"created_at": timeutils.utcnow(),
"updated_at": timeutils.utcnow(),
"deleted_at": timeutils.utcnow(),
"error_detail": "My cluster's error(s) detail",
"group_id": UUID4,
}
cluster = models.Cluster()
cluster.update(cluster_values)
self.assertEqual(cluster_values["id"], cluster.id, "Invalid ID value")
self.assertEqual(cluster_values["project_id"], cluster.project_id,
"Invalid project_id value")
self.assertEqual(cluster_values["network_id"], cluster.network_id,
"Invalid network_id value")
self.assertEqual(cluster_values["name"], cluster.name, "Invalid name"
"value")
self.assertEqual(cluster_values["status"], cluster.status, "Invalid "
"status"
"value")
self.assertEqual(cluster_values["flavor"], cluster.flavor,
"Invalid flavor value")
self.assertEqual(cluster_values["size"], cluster.size,
"Invalid size value")
self.assertEqual(cluster_values["volume_size"], cluster.volume_size,
"Invalid volume_size value")
self.assertEqual(cluster_values["deleted"], cluster.deleted,
"Invalid deleted value")
self.assertEqual(cluster_values["created_at"], cluster.created_at,
"Invalid created_at value")
self.assertEqual(cluster_values["updated_at"], cluster.updated_at,
"Invalid updated_at value")
self.assertEqual(cluster_values["deleted_at"], cluster.deleted_at,
"Invalid deleted_at value")
self.assertEqual(cluster_values["error_detail"], cluster.error_detail,
"Invalid error_detail value")
self.assertEqual(cluster_values["group_id"], cluster.group_id,
"Invalid group_id value")
db_session = sql_api.get_session()
cluster.save(db_session)
dbapi = db_api.get_instance()
cluster_db = dbapi.get_cluster_by_id(self.context,
cluster_values["id"])
self.assertEqual(cluster_values["id"], cluster_db.id, "Invalid ID "
"value")
self.assertEqual(cluster_values["project_id"], cluster_db.project_id,
"Invalid project_id value")
self.assertEqual(cluster_values["network_id"], cluster_db.network_id,
"Invalid network_id value")
self.assertEqual(cluster_values["name"], cluster_db.name, "Invalid "
"name value")
self.assertEqual(cluster_values["status"], cluster_db.status,
"Invalid status value")
self.assertEqual(cluster_values["flavor"], cluster_db.flavor,
"Invalid flavor value")
self.assertEqual(cluster_values["size"], cluster_db.size,
"Invalid size value")
self.assertEqual(cluster_values["volume_size"], cluster_db.volume_size,
"Invalid volume_size value")
self.assertEqual(cluster_values["deleted"], cluster_db.deleted,
"Invalid deleted value")
self.assertEqual(cluster_values["created_at"], cluster_db.created_at,
"Invalid created_at value")
self.assertEqual(cluster_values["updated_at"], cluster_db.updated_at,
"Invalid updated_at value")
self.assertEqual(cluster_values["deleted_at"], cluster_db.deleted_at,
"Invalid deleted_at value")
self.assertEqual(cluster_values["error_detail"],
cluster_db.error_detail, "Invalid error_detail value")
self.assertEqual(cluster_values["group_id"], cluster_db.group_id,
"Invalid group_id value")
def test_create_endpoint_model(self):
"""Verifies a new cluster record is created in DB."""
dbapi = db_api.get_instance()
cluster_values = {
"network_id": UUID3,
"project_id": UUID2,
"name": "Cluster test",
"flavor": "medium",
"size": 3,
"volume_size": 250,
}
db_cluster = dbapi.create_cluster(self.context, cluster_values)
node_values = {
"cluster_id": db_cluster.id,
"flavor": "Large",
"status": models.Status.BUILDING,
}
node = models.Node()
node.update(node_values)
db_session = sql_api.get_session()
node.save(db_session)
endpoint_values = {
"id": UUID1,
"node_id": node.id,
"uri": "amqp://10.20.30.40:10000",
"type": "AMQP",
"deleted": False,
}
endpoint = models.Endpoint()
endpoint.update(endpoint_values)
self.assertEqual(endpoint_values["id"], endpoint.id, "Invalid ID "
"value")
self.assertEqual(endpoint_values["node_id"], endpoint.node_id,
"Invalid node_id value")
self.assertEqual(endpoint_values["uri"], endpoint.uri, "Invalid uri"
"value")
self.assertEqual(endpoint_values["type"], endpoint.type, "Invalid "
"type"
"value")
self.assertEqual(endpoint_values["deleted"], endpoint.deleted,
"Invalid deleted value")
endpoint.save(db_session)
endpoint_db = dbapi.get_endpoint_by_id(self.context,
endpoint_values["id"])
self.assertEqual(endpoint_values["id"], endpoint_db.id, "Invalid ID "
"value")
self.assertEqual(endpoint_values["node_id"], endpoint_db.node_id,
"Invalid node_id value")
self.assertEqual(endpoint_values["uri"], endpoint_db.uri, "Invalid uri"
"value")
self.assertEqual(endpoint_values["type"], endpoint_db.type, "Invalid "
"type"
"value")
self.assertEqual(endpoint_values["deleted"], endpoint_db.deleted,
"Invalid deleted value")
def test_create_node_model(self):
"""Verifies a new cluster record is created in DB."""
dbapi = db_api.get_instance()
cluster_values = {
"network_id": UUID3,
"project_id": UUID2,
"name": "Cluster test",
"flavor": "medium",
"size": 3,
"volume_size": 250,
}
db_cluster = dbapi.create_cluster(self.context, cluster_values)
node_values = {
"id": UUID1,
"cluster_id": db_cluster.id,
"instance_id": "NovaInstanceId",
"flavor": "Large",
"status": models.Status.BUILDING,
"deleted": False,
"created_at": timeutils.utcnow(),
"updated_at": timeutils.utcnow(),
"deleted_at": timeutils.utcnow(),
}
node = models.Node()
node.update(node_values)
self.assertEqual(node_values["id"], node.id, "Invalid ID value")
self.assertEqual(node_values["cluster_id"], node.cluster_id,
"Invalid cluster_id value")
self.assertEqual(node_values["instance_id"], node.instance_id,
"Invalid instance_id value")
self.assertEqual(node_values["status"], node.status, "Invalid status "
"value")
self.assertEqual(node_values["flavor"], node.flavor, "Invalid flavor "
"value")
self.assertEqual(node_values["deleted"], node.deleted,
"Invalid deleted value")
self.assertEqual(node_values["created_at"], node.created_at,
"Invalid created_at value")
self.assertEqual(node_values["updated_at"], node.updated_at,
"Invalid updated_at value")
self.assertEqual(node_values["deleted_at"], node.deleted_at,
"Invalid deleted_at value")
db_session = sql_api.get_session()
node.save(db_session)
node_db = dbapi.get_node_by_id(self.context, node_values["id"])
self.assertEqual(node_values["id"], node_db.id, "Invalid ID value")
self.assertEqual(node_values["cluster_id"], node_db.cluster_id,
"Invalid cluster_id value")
self.assertEqual(node_values["instance_id"], node_db.instance_id,
"Invalid instance_id value")
self.assertEqual(node_values["status"], node_db.status, "Invalid "
"status value")
self.assertEqual(node_values["flavor"], node_db.flavor, "Invalid "
"flavor value")
self.assertEqual(node_values["deleted"], node_db.deleted,
"Invalid deleted value")
self.assertEqual(node_values["created_at"], node_db.created_at,
"Invalid created_at value")
self.assertEqual(node_values["updated_at"], node_db.updated_at,
"Invalid updated_at value")
self.assertEqual(node_values["deleted_at"], node_db.deleted_at,
"Invalid deleted_at value")
class BrokerObjectsTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def create_object_broker_metadata(self, broker_id, **kw):
"""Create broker_metadata object for the given broker."""
test_metadata_dict = func_utils.get_test_broker_metadata_dict(
broker_id=broker_id, **kw)
new_broker_metadata = objects.BrokerMetadata(**test_metadata_dict)
self.validate_broker_metadata_values(new_broker_metadata,
test_metadata_dict)
new_broker_metadata.create_broker_metadata(self.context)
return new_broker_metadata
def validate_broker_metadata_values(self, metadata_ref, metadata_cmp):
"""Validate Broker_Metadata Object fields."""
self.assertEqual(
metadata_ref.id if hasattr(
metadata_ref, "id") else metadata_ref["id"], metadata_cmp.id
if hasattr(metadata_cmp, "id") else metadata_cmp["id"],
"Invalid broker id value")
self.assertEqual(
metadata_ref.broker_id if hasattr(metadata_ref, "broker_id") else
metadata_ref["broker_id"], metadata_cmp.broker_id if hasattr(
metadata_cmp, "broker_id") else metadata_cmp["broker_id"],
"Invalid broker_id value")
self.assertEqual(
metadata_ref.key if hasattr(
metadata_ref, "key") else metadata_ref["key"], metadata_cmp.key
if hasattr(metadata_cmp, "key") else metadata_cmp["key"],
"Invalid key value")
self.assertEqual(
metadata_ref.value if hasattr(metadata_ref, "value") else
metadata_ref["value"], metadata_cmp.value if hasattr(
metadata_cmp, "value") else metadata_cmp["value"],
"Invalid value")
self.assertTrue(
test_utils.compare_dates(metadata_ref["created_at"],
metadata_cmp["created_at"]),
"Invalid created_at value")
self.assertTrue(
test_utils.compare_dates(metadata_ref["updated_at"],
metadata_cmp["updated_at"]),
"Invalid updated_at value")
self.assertTrue(
test_utils.compare_dates(metadata_ref["deleted_at"],
metadata_cmp["deleted_at"]),
"Invalid deleted_at value")
def test_broker_metadata_object_generation(self):
"""Test BrokerMetadata Object generation from a metadata dictionary."""
metadata_dict = func_utils.get_test_broker_metadata_dict()
metadata_object = objects.BrokerMetadata(**metadata_dict)
self.validate_broker_metadata_values(metadata_dict, metadata_object)
def test_broker_metadata_db_to_object_to_db(self):
"""Tests BrokerMetadata db object conversion to BrokerMetadata object
and back to db object.
"""
metadata_dict = func_utils.get_test_broker_metadata_dict()
db_metadata_object = models.BrokerMetadata()
db_metadata_object.update(metadata_dict)
object_metadata = objects.BrokerMetadata._from_db_object(
objects.BrokerMetadata(), db_metadata_object)
self.validate_broker_metadata_values(db_metadata_object,
object_metadata)
metadata_changes = object_metadata.obj_get_changes()
db_metadata_object_2 = models.BrokerMetadata()
db_metadata_object_2.update(metadata_changes)
self.validate_broker_metadata_values(db_metadata_object,
db_metadata_object_2)
def test_create_broker_metadata(self):
"""Tests create broker_metadata from BrokerMetadata objects API."""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
test_metadata_dict = func_utils.get_test_broker_metadata_dict()
new_broker_metadata = objects.BrokerMetadata(**test_metadata_dict)
self.validate_broker_metadata_values(new_broker_metadata,
test_metadata_dict)
new_broker_metadata.create_broker_metadata(self.context)
returned_broker_metadata = self.dbapi.get_broker_metadata_by_broker_id(
self.context, new_broker.id)
self.validate_broker_metadata_values(new_broker_metadata,
returned_broker_metadata[0])
def test_create_broker_metadata_for_nonexistent_broker(self):
"""Tests create broker_metadata for a nonexistent broker from
BrokerMetadata objects API.
"""
test_metadata_dict = func_utils.get_test_broker_metadata_dict(
broker_id=str(uuid.uuid4()))
new_broker_metadata = objects.BrokerMetadata(**test_metadata_dict)
self.validate_broker_metadata_values(new_broker_metadata,
test_metadata_dict)
self.assertRaises(exception.NotFound,
new_broker_metadata.create_broker_metadata,
self.context)
def test_get_broker_metadata_by_broker_id(self):
"""Tests get broker_metadata by broker_id from BrokerMetadata objects
API.
"""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
broker_metadata_1 = self.create_object_broker_metadata(
broker_id=new_broker.id)
broker_metadata_2 = self.create_object_broker_metadata(
broker_id=new_broker.id,
id='a2dcf598-ef5d-11e4-90ec-1681e6b88ec1',
key='SEC_GROUP',
value='test')
metadata_list = (
objects.BrokerMetadata.get_broker_metadata_by_broker_id(
self.context, new_broker.id))
# check for the list length
self.assertEqual(2, len(metadata_list), "Invalid number of "
"broker_metadata returned")
for metadata in metadata_list:
if metadata.id == broker_metadata_1.id:
self.validate_broker_metadata_values(broker_metadata_1,
metadata)
else:
self.validate_broker_metadata_values(broker_metadata_2,
metadata)
def test_get_broker_metadata_by_invalid_broker_id(self):
"""Tests get broker_metadata from BrokerMetadata objects API with
invalid broker id.
"""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
self.create_object_broker_metadata(broker_id=new_broker.id)
invalid_broker_id = '17efe8ae-e93c-11e4-b02c-1681e6b88ec1'
metadata = objects.BrokerMetadata.get_broker_metadata_by_broker_id(
self.context, invalid_broker_id)
self.assertListEqual([], metadata)
def test_get_image_id_by_broker_name(self):
"""Tests get broker image_id by broker_name from BrokerMetadata objects
API.
"""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
test_metadata_dict = func_utils.get_test_broker_metadata_dict()
new_broker_metadata = objects.BrokerMetadata(**test_metadata_dict)
self.validate_broker_metadata_values(new_broker_metadata,
test_metadata_dict)
new_broker_metadata.create_broker_metadata(self.context)
image_id = objects.BrokerMetadata.get_image_id_by_broker_name(
self.context, new_broker.name)
self.assertEqual(image_id, new_broker_metadata.value)
def test_get_image_id_by_nonexistent_broker_name(self):
"""Tests get broker image_id by nonexistent broker_name from
BrokerMetadata objects API.
"""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
self.create_object_broker_metadata(broker_id=new_broker.id)
invalid_broker_name = "kafka"
self.assertRaises(exception.NotFound,
objects.BrokerMetadata.get_image_id_by_broker_name,
self.context, invalid_broker_name)
def test_delete_broker_metadata(self):
"""Tests delete broker_metadata from BrokerMetadata objects API."""
new_broker = objects.Broker(**func_utils.get_test_broker_dict())
new_broker.create_broker(self.context)
new_broker_metadata = self.create_object_broker_metadata(
broker_id=new_broker.id)
new_broker_metadata.delete_broker_metadata(self.context)
metadata_returned = self.dbapi.get_broker_metadata_by_broker_id(
self.context, new_broker_metadata.broker_id)
self.assertListEqual([], metadata_returned)
class Cluster(base.CueObject):
dbapi = db_api.get_instance()
fields = {
'id': obj_utils.str_or_none,
'network_id': obj_utils.str_or_none,
'project_id': obj_utils.str_or_none,
'name': obj_utils.str_or_none,
'status': obj_utils.str_or_none,
'flavor': obj_utils.str_or_none,
'size': obj_utils.int_or_none,
'volume_size': obj_utils.int_or_none,
'deleted': obj_utils.bool_or_none,
'created_at': obj_utils.datetime_or_str_or_none,
'updated_at': obj_utils.datetime_or_str_or_none,
'deleted_at': obj_utils.datetime_or_str_or_none,
'error_detail': obj_utils.str_or_none,
'group_id': obj_utils.str_or_none,
}
@staticmethod
def _from_db_object(cluster, db_cluster):
"""Convert a database object to a universal cluster object."""
for field in cluster.fields:
cluster[field] = db_cluster[field]
return cluster
def create(self, context):
"""Creates a new cluster.
:param context: The request context
"""
self['project_id'] = context.project_id
cluster_changes = self.obj_get_changes()
db_cluster = self.dbapi.create_cluster(context, cluster_changes)
self._from_db_object(self, db_cluster)
def update(self, context, cluster_id, *args, **kwargs):
"""Updates a database cluster object.
:param context: The request context
:param cluster_id:
"""
cluster_changes = self.obj_get_changes()
self.dbapi.update_cluster(context, cluster_changes,
cluster_id, *args, **kwargs)
@classmethod
def get_clusters(cls, context, *args, **kwargs):
"""Returns a list of Cluster objects for project_id.
:param context: The request context.
:returns: a list of :class:'Cluster' object.
"""
db_clusters = cls.dbapi.get_clusters(context, *args, **kwargs)
return [Cluster._from_db_object(Cluster(), obj) for obj in db_clusters]
@classmethod
def get_cluster_by_id(cls, context, cluster_id):
"""Returns a Cluster objects for specified cluster_id.
:param context: The request context
:param cluster_id: the cluster_id to retrieve
:returns: a :class:'Cluster' object
"""
db_cluster = cls.dbapi.get_cluster_by_id(context, cluster_id)
return Cluster._from_db_object(Cluster(), db_cluster)
@classmethod
def update_cluster_deleting(cls, context, cluster_id):
"""Marks specified cluster to indicate deletion.
:param context: The request context
:param cluster_id: UUID of a cluster
"""
cls.dbapi.update_cluster_deleting(context, cluster_id)
class EndpointObjectsTests(base.FunctionalTestCase):
dbapi = db_api.get_instance()
def create_object_endpoint(self, node_id, **kw):
"""Create an endpoint object for the given node."""
endpoint_dict = func_utils.get_test_endpoint_dict(node_id=node_id,
**kw)
api_endpoint = objects.Endpoint(**endpoint_dict)
self.validate_endpoint_values(endpoint_dict, api_endpoint)
api_endpoint.create(self.context)
new_endpoint = self.dbapi.get_endpoints_in_node(
self.context, api_endpoint.node_id)
return new_endpoint[0]
def validate_endpoint_values(self, endpoint_ref, endpoint_cmp):
"""Validate Endpoint Object fields."""
if not (isinstance(endpoint_ref, cluster.EndPoint)
or isinstance(endpoint_cmp, cluster.EndPoint)):
self.assertEqual(
endpoint_ref.id if hasattr(endpoint_ref, "id") else
endpoint_ref["id"], endpoint_cmp.id if hasattr(
endpoint_cmp, "id") else endpoint_cmp["id"],
"Invalid endpoint id value")
self.assertEqual(
endpoint_ref.node_id if hasattr(endpoint_ref, "node_id") else
endpoint_ref["node_id"], endpoint_cmp.node_id if hasattr(
endpoint_cmp, "node_id") else endpoint_cmp["node_id"],
"Invalid endpoint node_id value")
self.assertEqual(
endpoint_ref.uri if hasattr(
endpoint_ref, "uri") else endpoint_ref["uri"], endpoint_cmp.uri
if hasattr(endpoint_cmp, "uri") else endpoint_cmp["uri"],
"Invalid endpoint uri value")
self.assertEqual(
endpoint_ref.type if hasattr(endpoint_ref, "type") else
endpoint_ref["type"], endpoint_cmp.type if hasattr(
endpoint_cmp, "type") else endpoint_cmp["type"],
"Invalid endpoint type value")
def test_endpoint_object_generation(self):
"""Test Endpoint Object generation from a cluster dictionary object."""
endpoint_dict = func_utils.get_test_endpoint_dict()
endpoint_object = objects.Endpoint(**endpoint_dict)
self.validate_endpoint_values(endpoint_dict, endpoint_object)
def test_endpoint_api_to_object_to_api(self):
"""Tests Endpoint api object conversion to Endpoint object and back
to api object.
"""
endpoint_dict = func_utils.get_test_endpoint_dict()
api_endpoint = cluster.EndPoint(**endpoint_dict)
object_endpoint = objects.Endpoint(**endpoint_dict)
self.validate_endpoint_values(api_endpoint, object_endpoint)
api_endpoint_2 = cluster.EndPoint(**object_endpoint.as_dict())
self.validate_endpoint_values(api_endpoint, api_endpoint_2)
def test_endpoint_db_to_object_to_db(self):
"""Tests Endpoint db object conversion to Endpoint object and back
to db object.
"""
endpoint_dict = func_utils.get_test_endpoint_dict()
db_endpoint_object = models.Endpoint()
db_endpoint_object.update(endpoint_dict)
object_endpoint = objects.Endpoint._from_db_object(
objects.Endpoint(), db_endpoint_object)
self.validate_endpoint_values(db_endpoint_object, object_endpoint)
endpoint_changes = object_endpoint.obj_get_changes()
db_endpoint_object_2 = models.Endpoint()
db_endpoint_object_2.update(endpoint_changes)
self.validate_endpoint_values(db_endpoint_object, db_endpoint_object_2)
def test_create_endpoint(self):
"""Tests create endpoint from Endpoint objects API."""
new_cluster = func_utils.create_object_cluster(self.context)
cluster_nodes = self.dbapi.get_nodes_in_cluster(
self.context, new_cluster.id)
endpoint_dict = func_utils.get_test_endpoint_dict(
node_id=cluster_nodes[0].id)
endpoint = objects.Endpoint(**endpoint_dict)
self.validate_endpoint_values(endpoint_dict, endpoint)
endpoint.create(self.context)
new_endpoint = self.dbapi.get_endpoints_in_node(
self.context, endpoint.node_id)
self.validate_endpoint_values(endpoint, new_endpoint[0])
def test_create_endpoint_for_nonexistent_node(self):
"""Tests create endpoint for a nonexistent node from Endpoint
objects API.
"""
api_endpoint_dict = func_utils.get_test_endpoint_dict()
api_endpoint = objects.Endpoint(**api_endpoint_dict)
self.validate_endpoint_values(api_endpoint_dict, api_endpoint)
self.assertRaises(oslo_exception.DBReferenceError, api_endpoint.create,
self.context)
def test_update_endpoint_by_node_id(self):
"""Tests update endpoint by node id from Endpoint objects API."""
new_cluster = func_utils.create_object_cluster(self.context, size=1)
cluster_node = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)
cluster_node_id = cluster_node[0].id
new_endpoint = self.create_object_endpoint(cluster_node_id,
uri='10.0.0.1:5672',
type='AMQP')
endpoint_values = {'uri': '10.0.0.2:5672', 'type': 'XMPP'}
objects.Endpoint.update_by_node_id(self.context, new_endpoint.node_id,
endpoint_values)
endpoints = self.dbapi.get_endpoints_in_node(self.context,
new_endpoint.node_id)
for endpoint in endpoints:
self.assertEqual('XMPP', endpoint.type)
self.assertEqual('10.0.0.2:5672', endpoint.uri)
def test_get_endpoints_by_node_id(self):
"""Tests get endpoint by node id from Endpoint objects API."""
new_cluster = func_utils.create_object_cluster(self.context, size=1)
cluster_node = self.dbapi.get_nodes_in_cluster(self.context,
new_cluster.id)
node_id = cluster_node[0].id
new_endpoint = self.create_object_endpoint(node_id)
endpoint_list = objects.Endpoint.get_endpoints_by_node_id(
self.context, new_endpoint.node_id)
for endpoint in endpoint_list:
self.validate_endpoint_values(endpoint, new_endpoint)
class CheckClusterStatusTests(base.FunctionalTestCase):
additional_fixtures = [
nova.NovaClient, neutron.NeutronClient, urllib2_fixture.Urllib2Fixture
]
dbapi = db_api.get_instance()
def setUp(self):
super(CheckClusterStatusTests, self).setUp()
flavor_name = "m1.tiny"
network_name = "private"
management_network_name = "cue_management_net"
self.nova_client = client.nova_client()
self.neutron_client = client.neutron_client()
self.port = '5672'
self.new_vm_name = str(uuid.uuid4())
self.new_vm_list = []
image_list = self.nova_client.images.list()
for image in image_list:
if (image.name.startswith("cirros")) and (
image.name.endswith("kernel")):
break
self.valid_image = image
self.valid_flavor = self.nova_client.flavors.find(name=flavor_name)
network_list = self.neutron_client.list_networks(name=network_name)
self.valid_network = network_list['networks'][0]
network_list = self.neutron_client.list_networks(
name=management_network_name)
self.management_network = network_list['networks'][0]
# Todo(Dan) If testing becomes asynchronous, then there is no guarantee
# that these urllib return results will come in the proper order. Will
# have to update the urllib2 fixture to respond appropriately for the
# url passed in.
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result(
['{"status": "ok"}', '[{"name": "/"}]'])
def test_check_cluster_status_active(self):
flow_store_create = {
"tenant_id": str(self.valid_network['tenant_id']),
"image": self.valid_image.id,
"flavor": self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
flow_store_check = {
"context": self.context.to_dict(),
"default_rabbit_user": "******",
"default_rabbit_pass": "******"
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": str(uuid.uuid4()),
"flavor": "1",
"size": 2,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
node_ids = []
for node in nodes:
node_ids.append(str(node.id))
flow_create = create_cluster(new_cluster.id, node_ids,
self.valid_network['id'],
self.management_network['id'])
engines.run(flow_create, store=flow_store_create)
cluster_before = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE, cluster_before.status,
"Invalid status for cluster")
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result([
'{"status": "ok"}',
'[{"name": "/"}]',
'{"status": "not-ok"}',
'[{"name": "/"}]',
])
flow_check_status = check_cluster_status(str(new_cluster.id), node_ids)
result = engines.run(flow_check_status, store=flow_store_check)
cluster_after = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE, cluster_after.status,
"Invalid status for cluster")
nodes_after = objects.Node.get_nodes_by_cluster_id(
self.context, new_cluster.id)
for i, node in enumerate(nodes_after):
self.assertEqual(result["node_values_%d" % i]["status"],
node.status, "Invalid status for node %d" % i)
def test_check_cluster_status_down(self):
flow_store_create = {
"tenant_id": str(self.valid_network['tenant_id']),
"image": self.valid_image.id,
"flavor": self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
flow_store_check = {
"context": self.context.to_dict(),
"default_rabbit_user": "******",
"default_rabbit_pass": "******"
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": str(uuid.uuid4()),
"flavor": "1",
"size": 2,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
node_ids = []
for node in nodes:
node_ids.append(str(node.id))
flow_create = create_cluster(new_cluster.id, node_ids,
self.valid_network['id'],
self.management_network['id'])
engines.run(flow_create, store=flow_store_create)
cluster_before = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE, cluster_before.status,
"Invalid status for cluster")
# mock cluster status returned by each node in cluster
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result([
'{"status": "not-ok"}',
'[{"name": "/"}]',
'{"status": "not-ok"}',
'[{"name": "/"}]',
])
flow_check_status = check_cluster_status(str(new_cluster.id), node_ids)
result = engines.run(flow_check_status, store=flow_store_check)
cluster_after = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.DOWN, cluster_after.status,
"Invalid status for cluster")
nodes_after = objects.Node.get_nodes_by_cluster_id(
self.context, new_cluster.id)
for i, node in enumerate(nodes_after):
self.assertEqual(models.Status.DOWN,
result["node_values_%d" % i]["status"])
self.assertEqual(models.Status.DOWN, node.status,
"Invalid status for node %d" % i)
def test_check_cluster_status_size_one(self):
flow_store_create = {
"tenant_id": str(self.valid_network['tenant_id']),
"image": self.valid_image.id,
"flavor": self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
flow_store_check = {
"context": self.context.to_dict(),
"default_rabbit_user": "******",
"default_rabbit_pass": "******"
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": str(uuid.uuid4()),
"flavor": "1",
"size": 1,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
node_ids = []
for node in nodes:
node_ids.append(str(node.id))
flow_create = create_cluster(new_cluster.id, node_ids,
self.valid_network['id'],
self.management_network['id'])
engines.run(flow_create, store=flow_store_create)
cluster_before = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE, cluster_before.status,
"Invalid status for cluster")
# mock cluster status returned by each node in cluster
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result([
'{"status": "ok"}',
'[{"name": "/"}]',
])
flow_check_status = check_cluster_status(str(new_cluster.id), node_ids)
result = engines.run(flow_check_status, store=flow_store_check)
cluster_after = objects.Cluster.get_cluster_by_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE, cluster_after.status,
"Invalid status for cluster")
nodes_after = objects.Node.get_nodes_by_cluster_id(
self.context, new_cluster.id)
self.assertEqual(models.Status.ACTIVE,
result["node_values_0"]["status"])
self.assertEqual(models.Status.ACTIVE, nodes_after[0].status,
"Invalid status for node")
def tearDown(self):
for vm_id in self.new_vm_list:
self.nova_client.servers.delete(vm_id)
super(CheckClusterStatusTests, self).tearDown()