class TopologyFunder(CTXPropRegistry):
"""In charge of ctx topology.
"""
__datatype__ = 'topology' #: default datatype name
def __init__(self, *args, **kwargs):
super(TopologyFunder, self).__init__(*args, **kwargs)
self.manager = TopologyManager()
def _get_documents(self, ids, query, *args, **kwargs):
result = []
ctx_id_field = self._ctx_id_field()
entity_cst = TopoVertice.ENTITY
info_cst = Vertice.INFO
entity = (
{'$exists': True} if ids is None else {'$in': ids}
)
info = {entity_cst: entity}
docs = self.manager.get_elts(info=info, serialize=False, query=query)
for doc in docs:
doc[ctx_id_field] = doc[info_cst][entity_cst]
result.append(doc)
return result
def _get(self, ids, query, *args, **kwargs):
return self._get_documents(ids=ids, query=query)
def _delete(self, ids, query, *args, **kwargs):
result = self._get_documents(ids=ids, query=query)
ids = [doc['_id'] for doc in result]
self.manager.del_elts(ids=ids)
return result
def ids(self, query=None):
result = set()
elts = self.manager.get_elts(query=query)
for elt in elts:
result.add(elt.entity)
return result
def fire_events():
manager = TopologyManager()
publisher = Amqp()
graphs = manager.get_graphs()
for graph in graphs:
graph.state = 0
event = graph.get_event(state=0)
publish(publisher=publisher, event=event)
def delete_topology(self, comp_ID):
# Initialize the Toplogy Manager
manager = TopologyManager()
# Create the topology name
top = manager.get_graphs(ids=comp_ID)
if top is not None:
top.delete(manager)
self.logger.info('Component {} is deleted ...'.format(comp_ID))
print 'Component {} is deleted'.format(comp_ID)
else:
self.logger.info('Component {} does no exist in the Database ...'.format(comp_ID))
print 'Component {} does no exist in the Database ...'.format(comp_ID)
class _AtLeastTest(TestCase):
"""
Default test class for at least function.
"""
def setUp(self):
self.manager = TopologyManager(data_scope='topology_test')
def tearDown(self):
"""
Drop nodes and edges.
"""
self.manager.del_elts()
class TopologyGraphTest(TestCase):
"""Test topology element.
"""
def setUp(self):
self.context = Context(data_scope='test')
self.manager = TopologyManager(data_scope='test')
def tearDown(self):
self.context.remove()
self.manager.del_elts()
def test_save(self):
"""Test if an entity exists after saving a topology.
"""
id = 'test'
topology = Topology(id=id)
topology.save(manager=self.manager, context=self.context)
topology = self.context.get(_type=topology.type, names=id)
self.assertEqual(topology[Context.NAME], id)
def test_delete(self):
"""Test if topology nodes exist after deleting a topology.
"""
topology = Topology()
node = TopoNode()
topology.add_elts(node)
topology.save(manager=self.manager)
node = self.manager.get_elts(node.id)
self.assertIsNotNone(node)
topology.delete(manager=self.manager)
node = self.manager.get_elts(node.id)
self.assertIsNone(node)
def setUp(self):
self.context = Context(data_scope='test_context')
self.manager = TopologyManager(data_scope='test_topology')
self.check = {
'type': 'check',
'event_type': 'check',
'connector': 'c',
'connector_name': 'c',
'component': 'c',
'source_type': 'component',
'state': Check.OK
}
entity = self.context.get_entity(self.check)
entity_id = self.context.get_entity_id(entity)
self.node = TopoNode(entity=entity_id)
self.node.save(self.manager)
self.count = 0
self.amqp = ProcessingTest._Amqp(self)
def __init__(self, *args, **kwargs):
super(TopologyFunder, self).__init__(*args, **kwargs)
self.manager = TopologyManager()
def setUp(self):
self.manager = TopologyManager(data_scope='test')
class TopoNodeTest(TestCase):
"""Test event processing function.
"""
def setUp(self):
self.manager = TopologyManager(data_scope='test')
def tearDown(self):
self.manager.del_elts()
def test_default(self):
"""Test to process a toponode without default task.
"""
toponode = TopoNode()
self.assertEqual(toponode.state, 0)
event = {'state': 1}
result = toponode.process(event=event, manager=self.manager)
self.assertIsNone(result)
self.assertEqual(toponode.state, 1)
def test_process_task(self):
"""Process a task which returns all toponode data.
"""
@register_task('process')
def process_node(
vertice, ctx,
event=None, publisher=None, source=None, manager=None, logger=None,
**kwargs
):
return vertice, ctx, kwargs
ctx, entity, state, operation = {'b': 1}, 'e', 0, 'process'
toponode = TopoNode(state=state, entity=entity, operation=operation)
_node, _ctx, _kwargs = toponode.process(
ctx=ctx, event=None, manager=self.manager
)
self.assertIs(_node, toponode)
self.assertIs(_ctx, ctx)
self.assertFalse(_kwargs)
def test_proccess_task_with_propagation(self):
"""Process a node and check if node and edge states have changed.
"""
state = 0
new_state = state + 1
operation = {
'id': 'canopsis.topology.rule.action.change_state',
'params': {'state': new_state}
}
toponode = TopoNode(state=state, operation=operation)
toponode.save(manager=self.manager)
edge = TopoEdge(sources=toponode)
edge.save(manager=self.manager)
self.assertEqual(toponode.state, state)
self.assertEqual(edge.state, state)
toponode.process(event={}, manager=self.manager)
elts = self.manager.get_elts(ids=[toponode.id, edge.id])
toponode = elts[0]
edge = elts[1]
self.assertEqual(toponode.state, new_state)
self.assertEqual(edge.state, new_state)
def setUp(self):
self.context = Context(data_scope='test')
self.manager = TopologyManager(data_scope='test')
class ProcessingTest(TestCase):
"""
Test event processing function.
"""
class _Amqp(object):
"""
In charge of processing publishing of test.
"""
def __init__(self, processingTest):
self.exchange_name_events = None
self.processingTest = processingTest
self.event = None
def publish(self, event, rk, exchange):
"""
Called when an event process publishes an event.
"""
self.event = event
self.processingTest.count += 1
event_processing(
event=event,
engine=self.processingTest,
manager=self.processingTest.manager
)
def setUp(self):
self.context = Context(data_scope='test_context')
self.manager = TopologyManager(data_scope='test_topology')
self.check = {
'type': 'check',
'event_type': 'check',
'connector': 'c',
'connector_name': 'c',
'component': 'c',
'source_type': 'component',
'state': Check.OK
}
entity = self.context.get_entity(self.check)
entity_id = self.context.get_entity_id(entity)
self.node = TopoNode(entity=entity_id)
self.node.save(self.manager)
self.count = 0
self.amqp = ProcessingTest._Amqp(self)
def tearDown(self):
self.manager.del_elts()
def test_no_bound(self):
"""
Test in case of not bound nodes.
"""
event_processing(event=self.check, engine=self, manager=self.manager)
self.assertEqual(self.count, 0)
def test_one_node(self):
"""
Test in case of one bound node
"""
source = TopoNode()
source.save(self.manager)
edge = TopoEdge(sources=source.id, targets=self.node.id)
edge.save(self.manager)
event_processing(event=self.check, engine=self, manager=self.manager)
self.assertEqual(self.count, 0)
def test_change_state(self):
"""
Test in case of change state.
"""
# create a change state operation with minor state
change_state_conf = new_conf(
change_state,
state=Check.MINOR
)
self.node.operation = change_state_conf
self.node.save(self.manager)
self.node.process(event=self.check, manager=self.manager)
event_processing(event=self.check, engine=self, manager=self.manager)
target = self.manager.get_elts(ids=self.node.id)
self.assertEqual(target.state, Check.MINOR)
def test_chain_change_state(self):
"""
Test to change of state in a chain of nodes.
This test consists to link three node in such way:
self.node(state=0) -> node(state=0) -> root(state=0)
And to propagate the change state task with state = 1 in order to check
if root state equals 1.
"""
# create a simple task which consists to change of state
change_state_conf = new_conf(
change_state,
state=Check.MINOR
)
# create a root node with the change state task
root = TopoNode(operator=change_state_conf)
root.save(self.manager)
# create a node with the change state task
node = TopoNode(operator=change_state_conf)
node.save(self.manager)
# create a leaf with the change state task
self.node.operation = change_state_conf
self.node.save(self.manager)
# link node to root
rootnode = TopoEdge(targets=root.id, sources=node.id)
rootnode.save(self.manager)
# link self.node to node
self_node = TopoEdge(targets=node.id, sources=self.node.id)
self_node.save(self.manager)
event_processing(event=self.check, engine=self, manager=self.manager)
self.assertEqual(self.count, 3)
self.node = self.manager.get_elts(ids=self.node.id)
self.assertEqual(self.node.state, Check.MINOR)