def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def setUp(self):
config = CfgParser(
"--http_server_port 0 " "--zk_list 127.0.0.1:0 " "--disc_server_ip 127.0.0.1 " "--redis_server_port 0"
)
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
class TestAlarmGen(unittest.TestCase, TestChecker):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch("opserver.alarmgen.PartitionClient", autospec=True)
cls._pc.start()
cls._dc = mock.patch("opserver.alarmgen.client.DiscoveryClient", autospec=True)
cls._dc.start()
cls._kc = mock.patch("opserver.partition_handler.KafkaClient", autospec=True)
cls._kc.start()
cls._ac = mock.patch("opserver.alarmgen.KafkaClient", autospec=True)
cls._ac.start()
cls._sc = mock.patch("opserver.alarmgen.SimpleProducer", autospec=True)
cls._sc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
cls._ac.stop()
cls._sc.stop()
def setUp(self):
config = CfgParser(
"--http_server_port 0 " "--zk_list 127.0.0.1:0 " "--disc_server_ip 127.0.0.1 " "--redis_server_port 0"
)
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
@mock.patch("opserver.alarmgen.Controller.send_agg_uve")
@mock.patch.object(UVEServer, "get_part")
@mock.patch.object(UVEServer, "get_uve")
@mock.patch("opserver.partition_handler.SimpleConsumer", autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self, mock_SimpleConsumer, mock_get_uve, mock_get_part, mock_send_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1, ("127.0.0.1", 0, 0))] = "127.0.0.1:0", {"gen1": {"ObjectXX:uve1": {"type1": {}}}}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1": {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
@mock.patch("opserver.alarmgen.Controller.send_agg_uve")
@mock.patch.object(UVEServer, "get_part")
@mock.patch.object(UVEServer, "get_uve")
@mock.patch("opserver.partition_handler.SimpleConsumer", autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self, mock_SimpleConsumer, mock_get_uve, mock_get_part, mock_send_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1, ("127.0.0.1", 0, 0))] = "127.0.0.1:0", {"gen1": {"ObjectXX:uve1": {"type1": {}}}}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(
magic=0,
attributes=0,
key="",
value=(
'{"message":"UVEUpdate","key":"ObjectYY:uve2",'
'"type":"type2","gen":"gen1","coll":'
'"127.0.0.1:0","value":{}}'
),
),
)
mock_SimpleConsumer.return_value.get_messages.side_effect = m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2": {"yy": 1}}))
@mock.patch("opserver.alarmgen.Controller.send_agg_uve")
@mock.patch.object(UVEServer, "get_part")
@mock.patch.object(UVEServer, "get_uve")
@mock.patch("opserver.partition_handler.SimpleConsumer", autospec=True)
# Test late bringup of collector
# Also test collector shutdown
def test_02_collectorha(self, mock_SimpleConsumer, mock_get_uve, mock_get_part, mock_send_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1, ("127.0.0.1", 0, 0))] = "127.0.0.1:0", {"gen1": {"ObjectXX:uve1": {"type1": {}}}}
m_get_part[(1, ("127.0.0.5", 0, 0))] = "127.0.0.5:0", {"gen1": {"ObjectZZ:uve3": {"type3": {}}}}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
m_get_uve["ObjectZZ:uve3"] = {"type3": {"zz": 2}}
mock_get_uve.side_effect = m_get_uve
# When this message is read, 127.0.0.5 will not be present
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(
magic=0,
attributes=0,
key="",
value=(
'{"message":"UVEUpdate","key":"ObjectYY:uve2",'
'"type":"type2","gen":"gen1","coll":'
'"127.0.0.5:0","value":{} }'
),
),
)
mock_SimpleConsumer.return_value.get_messages.side_effect = m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
# Now bringup collector 127.0.0.5
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info, False))
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}, {"ip-address": "127.0.0.5", "pid": 0}])
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info, False))
# Feed the message in again
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(
magic=0,
attributes=0,
key="",
value=(
'{"message":"UVEUpdate","key":"ObjectYY:uve2",'
'"type":"type2","gen":"gen1","coll":'
'"127.0.0.5:0","value":{}}'
),
),
)
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
# Withdraw collector 127.0.0.1
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
del m_get_uve["ObjectXX:uve1"]
self._ag.disc_cb_coll([{"ip-address": "127.0.0.5", "pid": 0}])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
class TestAlarmGen(unittest.TestCase, TestChecker):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch('opserver.alarmgen.PartitionClient',
autospec=True)
cls._pc.start()
cls._dc = mock.patch('opserver.alarmgen.client.DiscoveryClient',
autospec=True)
cls._dc.start()
cls._kc = mock.patch('opserver.partition_handler.KafkaClient',
autospec=True)
cls._kc.start()
cls._ac = mock.patch('opserver.alarmgen.KafkaClient', autospec=True)
cls._ac.start()
cls._sc = mock.patch('opserver.alarmgen.SimpleProducer', autospec=True)
cls._sc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
cls._ac.stop()
cls._sc.stop()
def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
@staticmethod
def create_test_alarm_info(alarm_type):
elems = []
elems.append(
AlarmRule(oper="!=",
operand1=AlarmOperand(name="state", json_value="'DOWN'"),
operand2=AlarmOperand(name=None, json_value="'UP'")))
alarm_info = UVEAlarmInfo(type=alarm_type,
severity=1,
timestamp=UTCTimestampUsec(),
token="dummytoken",
rules=elems,
ack=False)
return alarm_info
# end create_test_alarm_info
def add_test_alarm(self, table, name, atype):
if not self._ag.tab_alarms.has_key(table):
self._ag.tab_alarms[table] = {}
key = table + ':' + name
if not self._ag.tab_alarms[table].has_key(key):
self._ag.tab_alarms[table][key] = {}
self._ag.tab_alarms[table][key][atype] = \
TestAlarmGen.create_test_alarm_info(atype)
# end add_test_alarm
def get_test_alarm(self, table, name, atype):
key = table + ':' + name
return self._ag.tab_alarms[table][key][atype]
# end get_test_alarm
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self, mock_SimpleConsumer, mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve,
mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1" : {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"],\
self._ag.ptab_info, False))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self, mock_SimpleConsumer, mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve,
mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(magic=0,
attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.1:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info,
False))
self.assertTrue(
self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2" : {"yy": 1}}))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test late bringup of collector
# Also test collector shutdown
def test_02_collectorha(self, mock_SimpleConsumer, mock_get_uve,
mock_get_part, mock_send_agg_uve,
mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : { "type1":{} } }}
m_get_part[(1,("127.0.0.5",0,0))] = "127.0.0.5:0", \
{ "gen1" :
{ "ObjectZZ:uve3" : { "type3":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
m_get_uve["ObjectZZ:uve3"] = {"type3": {"zz": 2}}
mock_get_uve.side_effect = m_get_uve
# When this message is read, 127.0.0.5 will not be present
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(magic=0,
attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
# Now bringup collector 127.0.0.5
self.assertTrue(
self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info,
False))
self._ag.disc_cb_coll([{
"ip-address": "127.0.0.1",
"pid": 0
}, {
"ip-address": "127.0.0.5",
"pid": 0
}])
self.assertTrue(
self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info))
self.assertTrue(
self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info,
False))
# Feed the message in again
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(magic=0,
attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
self.assertTrue(
self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
# Withdraw collector 127.0.0.1
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
del m_get_uve["ObjectXX:uve1"]
self._ag.disc_cb_coll([{"ip-address": "127.0.0.5", "pid": 0}])
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info,
False))
@mock.patch('opserver.alarmgen.AlarmTrace', autospec=True)
def test_03_alarm_ack_callback(self, MockAlarmTrace):
self._ag.tab_alarms = {}
self.add_test_alarm('table1', 'name1', 'type1')
self.add_test_alarm('table1', 'name1', 'type2')
tab_alarms_copy = copy.deepcopy(self._ag.tab_alarms)
TestCase = namedtuple('TestCase', ['name', 'input', 'output'])
TestInput = namedtuple('TestInput', ['alarm_ack_req'])
TestOutput = namedtuple('TestOutput',
['return_code', 'alarm_send', 'ack_values'])
tests = [
TestCase(
name='case 1: Invalid "table"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='invalid_table',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 2: Invalid "name"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='invalid_name', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 3: Invalid "type"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='invalid_type',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 4: Invalid "timestamp"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=\
SandeshAlarmAckResponseCode.INVALID_ALARM_REQUEST,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 5: Valid ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':False, 'type2':True})
),
TestCase(
name='case 6: Duplicate ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 7: Valid ack request - different alarm type',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type1').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':True, 'type2':True})
)
]
for case in tests:
logging.info('=== Test %s ===' % (case.name))
return_code = self._ag.alarm_ack_callback(case.input.alarm_ack_req)
# verify return code
self.assertEqual(case.output.return_code, return_code)
table = case.input.alarm_ack_req.table
name = case.input.alarm_ack_req.name
if case.output.alarm_send is True:
# verify alarm ack message is sent
uvekey = table + ':' + name
for atype, alarm in tab_alarms_copy[table][uvekey].iteritems():
if atype in case.output.ack_values:
alarm.ack = case.output.ack_values[atype]
alarms = copy.deepcopy(tab_alarms_copy[table][uvekey])
alarm_data = UVEAlarms(name=name, alarms=alarms.values())
MockAlarmTrace.assert_called_once_with(
data=alarm_data, table=table, sandesh=self._ag._sandesh)
MockAlarmTrace().send.assert_called_once_with(
sandesh=self._ag._sandesh)
MockAlarmTrace.reset_mock()
else:
class TestAlarmGen(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch('opserver.alarmgen.PartitionClient', autospec=True)
cls._pc.start()
cls._dc = mock.patch('opserver.alarmgen.client.DiscoveryClient', autospec=True)
cls._dc.start()
cls._kc = mock.patch('opserver.partition_handler.KafkaClient', autospec=True)
cls._kc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
@retry(delay=1, tries=3)
def checker_dict(self,expected,actual,match=True):
residual = actual
matched = True
result = False
for elem in expected:
if elem in residual:
residual = residual[elem]
else:
matched = False
if match:
result = matched
else:
result = not matched
if not result:
logging.info("exp %s actual %s match %s" % \
(str(expected), str(actual), str(match)))
return result
@retry(delay=1, tries=3)
def checker_exact(self,expected,actual,match=True):
result = False
if expected == actual:
return match
else:
result = not match
if not result:
logging.info("exp %s actual %s match %s" % \
(str(expected), str(actual), str(match)))
return result
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = {"127.0.0.1:0" :
{ "gen1" :
{ "ObjectXX:uve1" : set(["type1"]) }}}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1" : {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"],\
self._ag.ptab_info, False))
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = {"127.0.0.1:0" :
{ "gen1" :
{ "ObjectXX:uve1" : set(["type1"]) }}}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0, key='',
value=('{"message":"UVEUpdate","key":"ObjectYY:uve2",'
'"type":"type2","gen":"gen1","coll":'
'"127.0.0.1:0","deleted":false}')))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2" : {"yy": 1}}))
class TestAlarmGen(unittest.TestCase, TestChecker):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch('opserver.alarmgen.PartitionClient', autospec=True)
cls._pc.start()
cls._dc = mock.patch('opserver.alarmgen.client.DiscoveryClient', autospec=True)
cls._dc.start()
cls._kc = mock.patch('opserver.partition_handler.KafkaClient', autospec=True)
cls._kc.start()
cls._ac = mock.patch('opserver.alarmgen.KafkaClient', autospec=True)
cls._ac.start()
cls._sc = mock.patch('opserver.alarmgen.SimpleProducer', autospec=True)
cls._sc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
cls._ac.stop()
cls._sc.stop()
def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
def create_test_alarm_info(self, table, name, alarm_type):
or_list = []
condition_match = AlarmConditionMatch(
condition=AlarmCondition(operation="!=", operand1="dummytoken",
operand2=json.dumps("UP")),
match=[AlarmMatch(json_operand1_value=json.dumps("DOWN"))])
or_list.append(AlarmAndList([condition_match]))
uai = UVEAlarmInfo(type=alarm_type, severity=1,
timestamp=UTCTimestampUsec(),
token="dummytoken",
alarm_rules=AlarmRules(or_list), ack=False)
conf = UVEAlarmConfig()
state = UVEAlarmOperState(state = UVEAlarmState.Active,
head_timestamp = 0, alarm_timestamp = [])
uv = table + ':' + name
alarm_info = AlarmStateMachine(tab = table, uv = uv, nm = \
alarm_type, activeTimer = 0, idleTimer = 0, freqCheck_Times\
= 0, freqCheck_Seconds = 0, freqExceededCheck = False, sandesh=self._ag._sandesh)
alarm_info.set_uai(uai)
return alarm_info
# end create_test_alarm_info
def add_test_alarm(self, table, name, atype):
if not self._ag.tab_alarms.has_key(table):
self._ag.tab_alarms[table] = {}
key = table+':'+name
if not self._ag.tab_alarms[table].has_key(key):
self._ag.tab_alarms[table][key] = {}
self._ag.tab_alarms[table][key][atype] = \
self.create_test_alarm_info(table, name, atype)
# end add_test_alarm
def get_test_alarm(self, table, name, atype):
key = table+':'+name
return self._ag.tab_alarms[table][key][atype].get_uai(forced=True)
# end get_test_alarm
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1" : {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"],\
self._ag.ptab_info, False))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.1:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2" : {"yy": 1}}))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test late bringup of collector
# Also test collector shutdown
def test_02_collectorha(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : { "type1":{} } }}
m_get_part[(1,("127.0.0.5",0,0))] = "127.0.0.5:0", \
{ "gen1" :
{ "ObjectZZ:uve3" : { "type3":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
m_get_uve["ObjectZZ:uve3"] = {"type3": {"zz": 2}}
mock_get_uve.side_effect = m_get_uve
# When this message is read, 127.0.0.5 will not be present
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
# Now bringup collector 127.0.0.5
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info, False))
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}, {"ip-address":"127.0.0.5","pid":0}])
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info, False))
# Feed the message in again
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
# Withdraw collector 127.0.0.1
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
del m_get_uve["ObjectXX:uve1"]
self._ag.disc_cb_coll([{"ip-address":"127.0.0.5","pid":0}])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
@mock.patch('opserver.alarmgen.AlarmTrace', autospec=True)
def test_03_alarm_ack_callback(self, MockAlarmTrace):
self._ag.tab_alarms = {}
self.add_test_alarm('table1', 'name1', 'type1')
self.add_test_alarm('table1', 'name1', 'type2')
tab_alarms_copy = {}
for tab in self._ag.tab_alarms.keys():
for uk,uv in self._ag.tab_alarms[tab].iteritems():
for ak,av in uv.iteritems():
uai = av.get_uai(forced=True)
if uai:
if not tab in tab_alarms_copy.keys():
tab_alarms_copy[tab] = {}
if not uk in tab_alarms_copy[tab].keys():
tab_alarms_copy[tab][uk] = {}
tab_alarms_copy[tab][uk][ak] = copy.deepcopy(uai)
TestCase = namedtuple('TestCase', ['name', 'input', 'output'])
TestInput = namedtuple('TestInput', ['alarm_ack_req'])
TestOutput = namedtuple('TestOutput', ['return_code', 'alarm_send',
'ack_values'])
tests = [
TestCase(
name='case 1: Invalid "table"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='invalid_table',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 2: Invalid "name"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='invalid_name', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 3: Invalid "type"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='invalid_type',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 4: Invalid "timestamp"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=\
SandeshAlarmAckResponseCode.INVALID_ALARM_REQUEST,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 5: Valid ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':False, 'type2':True})
),
TestCase(
name='case 6: Duplicate ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 7: Valid ack request - different alarm type',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type1').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':True, 'type2':True})
)
]
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
get_uas().state = UVEAlarmState.Active
self._ag.tab_alarms['table1']['table1:name1']['type2'].\
get_uas().state = UVEAlarmState.Active
for case in tests:
logging.info('=== Test %s ===' % (case.name))
return_code = self._ag.alarm_ack_callback(case.input.alarm_ack_req)
# verify return code
self.assertEqual(case.output.return_code, return_code)
table = case.input.alarm_ack_req.table
name = case.input.alarm_ack_req.name
if case.output.alarm_send is True:
# verify alarm ack message is sent
uvekey = table+':'+name
for atype, alarm in tab_alarms_copy[table][uvekey].iteritems():
if atype in case.output.ack_values:
alarm.ack = case.output.ack_values[atype]
alarms = copy.deepcopy(tab_alarms_copy[table][uvekey])
alarm_data = UVEAlarms(name=name, alarms=alarms.values())
MockAlarmTrace.assert_called_once_with(data=alarm_data,
table=table, sandesh=self._ag._sandesh)
MockAlarmTrace().send.assert_called_once_with(
sandesh=self._ag._sandesh)
MockAlarmTrace.reset_mock()
else:
self.assertFalse(MockAlarmTrace.called)
# verify the alarm table after every call to alarm_ack_callback.
# verify that ack field is set in the alarm table upon
# successful acknowledgement and the table is untouched in case
# of failure.
#self.assertEqual(tab_alarms_copy, self._ag.tab_alarms)
for tab in self._ag.tab_alarms.keys():
for uk,uv in self._ag.tab_alarms[tab].iteritems():
for ak,av in uv.iteritems():
uai = av.get_uai(forced=True)
if uai:
self.assertEqual(uai, tab_alarms_copy[tab][uk][ak])
# end test_03_alarm_ack_callback
def test_04_alarm_state_machine(self):
self._ag.tab_alarms = {}
self.add_test_alarm('table1', 'name1', 'type1')
TestCase = namedtuple('TestCase', ['name', 'initial_state',
'timer', 'expected_output_state'])
set_alarm_test1 = [
TestCase (
name = "set alarm in Idle",
initial_state = UVEAlarmState.Idle,
timer = 1,
expected_output_state = UVEAlarmState.Soak_Active
),
]
test_count = 1
for case in set_alarm_test1:
logging.info('=== Test case%s %s ===' % (test_count, case.name))
test_count += 1
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
get_uas().state = case.initial_state
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
get_uac().ActiveTimer = case.timer
self._ag.tab_alarms['table1']['table1:name1']\
['type1'].set_alarms()
# verify output state
output_state = self._ag.tab_alarms['table1']['table1:name1']\
['type1'].get_uas().state
self.assertEqual(case.expected_output_state, output_state)
curr_time = int(time.time())
logging.info('=== Test case%s checking activeTimerExpiry ===' % (test_count))
test_count += 1
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(update_alarms, [])
curr_time += 1
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(len(update_alarms), 1)
clear_alarm_test1 = [
TestCase (
name = "clear alarm in Active",
initial_state = UVEAlarmState.Active,
timer = 0,
expected_output_state = UVEAlarmState.Idle
),
TestCase (
name = "case3 clear alarm in Active with Timer",
initial_state = UVEAlarmState.Active,
timer = 1,
expected_output_state = UVEAlarmState.Soak_Idle
),
]
for case in clear_alarm_test1:
logging.info('=== Test case%s %s ===' % (test_count, case.name))
test_count += 1
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uas.state = case.initial_state
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uac.IdleTimer = case.timer
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uac.FreqCheck_Seconds = case.timer
delete_alarm = self._ag.tab_alarms['table1']\
['table1:name1']['type1'].clear_alarms()
# verify output state
output_state = self._ag.tab_alarms['table1']['table1:name1']\
['type1'].uas.state
self.assertEqual(case.expected_output_state, output_state)
if(case.expected_output_state == UVEAlarmState.Idle):
self.assertEqual(delete_alarm, True)
elif case.expected_output_state == UVEAlarmState.Soak_Idle:
self.assertEqual(delete_alarm, False)
logging.info('=== Test case%s checking idleTimerExpiry ===' % (test_count))
test_count += 1
curr_time = int(time.time())
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(delete_alarms, [])
self.assertEqual(update_alarms, [])
curr_time += 1
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(len(delete_alarms), 0)
self.assertEqual(len(update_alarms), 1)
logging.info('=== Test case%s checking deleteTimerExpiry ===' % (test_count))
test_count += 1
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(delete_alarms, [])
curr_time += 1
delete_alarms, update_alarms = AlarmStateMachine.run_timers\
(curr_time, self._ag.tab_alarms)
self.assertEqual(len(delete_alarms), 1)
clear_alarm_test2 = [
TestCase (
name = "clear alarm in Active with Timer",
initial_state = UVEAlarmState.Active,
timer = 1,
expected_output_state = UVEAlarmState.Soak_Idle
),
]
for case in clear_alarm_test2:
logging.info('=== Test case%s %s ===' % (test_count, case.name))
test_count += 1
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uas.state = case.initial_state
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uac.IdleTimer = case.timer
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
uac.FreqCheck_Seconds = case.timer
delete_alarm = self._ag.tab_alarms['table1']\
['table1:name1']['type1'].clear_alarms()
# verify output state
output_state = self._ag.tab_alarms['table1']['table1:name1']\
['type1'].uas.state
self.assertEqual(case.expected_output_state, output_state)
self.assertEqual(delete_alarm, False)
set_alarm_test2 = [
TestCase (
name = "set alarm in Soak_Idle",
initial_state = UVEAlarmState.Soak_Idle,
timer = 1,
expected_output_state = UVEAlarmState.Active
),
]
for case in set_alarm_test2:
logging.info('=== Test case%s %s ===' % (test_count, case.name))
test_count += 1
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
get_uas().state = case.initial_state
self._ag.tab_alarms['table1']['table1:name1']['type1'].\
get_uac().ActiveTimer = case.timer
self._ag.tab_alarms['table1']['table1:name1']\
['type1'].set_alarms()
# verify output state
output_state = self._ag.tab_alarms['table1']['table1:name1']\
['type1'].get_uas().state
self.assertEqual(case.expected_output_state, output_state)
class TestAlarmGen(unittest.TestCase, TestChecker):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch('opserver.alarmgen.PartitionClient', autospec=True)
cls._pc.start()
cls._dc = mock.patch('opserver.alarmgen.client.DiscoveryClient', autospec=True)
cls._dc.start()
cls._kc = mock.patch('opserver.partition_handler.KafkaClient', autospec=True)
cls._kc.start()
cls._ac = mock.patch('opserver.alarmgen.KafkaClient', autospec=True)
cls._ac.start()
cls._sc = mock.patch('opserver.alarmgen.SimpleProducer', autospec=True)
cls._sc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
cls._ac.stop()
cls._sc.stop()
def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
@staticmethod
def create_test_alarm_info(alarm_type):
or_list = []
or_list.append([AllOf(all_of=[AlarmElement(\
rule=AlarmTemplate(oper="!=",
operand1=Operand1(keys=["dummytoken"]),
operand2=Operand2(json_value=json.dumps('UP'))),
json_operand1_value=json.dumps('DOWN'))])])
alarm_info = UVEAlarmInfo(type=alarm_type, severity=1,
timestamp=UTCTimestampUsec(),
token="dummytoken",
any_of=or_list, ack=False)
return alarm_info
# end create_test_alarm_info
def add_test_alarm(self, table, name, atype):
if not self._ag.tab_alarms.has_key(table):
self._ag.tab_alarms[table] = {}
key = table+':'+name
if not self._ag.tab_alarms[table].has_key(key):
self._ag.tab_alarms[table][key] = {}
self._ag.tab_alarms[table][key][atype] = \
TestAlarmGen.create_test_alarm_info(atype)
# end add_test_alarm
def get_test_alarm(self, table, name, atype):
key = table+':'+name
return self._ag.tab_alarms[table][key][atype]
# end get_test_alarm
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1" : {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"],\
self._ag.ptab_info, False))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : {"type1":{}} }}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.1:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2" : {"yy": 1}}))
@mock.patch('opserver.alarmgen.Controller.reconnect_agg_uve')
@mock.patch('opserver.alarmgen.Controller.clear_agg_uve')
@mock.patch('opserver.alarmgen.Controller.send_agg_uve')
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test late bringup of collector
# Also test collector shutdown
def test_02_collectorha(self,
mock_SimpleConsumer,
mock_get_uve, mock_get_part,
mock_send_agg_uve, mock_clear_agg_uve, mock_reconnect_agg_uve):
m_get_part = Mock_get_part()
m_get_part[(1,("127.0.0.1",0,0))] = "127.0.0.1:0", \
{ "gen1" :
{ "ObjectXX:uve1" : { "type1":{} } }}
m_get_part[(1,("127.0.0.5",0,0))] = "127.0.0.5:0", \
{ "gen1" :
{ "ObjectZZ:uve3" : { "type3":{}} }}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
m_get_uve["ObjectZZ:uve3"] = {"type3": {"zz": 2}}
mock_get_uve.side_effect = m_get_uve
# When this message is read, 127.0.0.5 will not be present
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}])
self._ag.libpart_cb([1])
# Now bringup collector 127.0.0.5
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info, False))
self._ag.disc_cb_coll([{"ip-address":"127.0.0.1","pid":0}, {"ip-address":"127.0.0.5","pid":0}])
self.assertTrue(self.checker_dict([1, "ObjectZZ", "uve3"], self._ag.ptab_info))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info, False))
# Feed the message in again
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(offset=0,
message=Message(magic=0, attributes=0,
key='ObjectYY:uve2|type2|gen1|127.0.0.5:0',
value='{}'))
self.assertTrue(self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
# Withdraw collector 127.0.0.1
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
del m_get_uve["ObjectXX:uve1"]
self._ag.disc_cb_coll([{"ip-address":"127.0.0.5","pid":0}])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info, False))
@mock.patch('opserver.alarmgen.AlarmTrace', autospec=True)
def test_03_alarm_ack_callback(self, MockAlarmTrace):
self._ag.tab_alarms = {}
self.add_test_alarm('table1', 'name1', 'type1')
self.add_test_alarm('table1', 'name1', 'type2')
tab_alarms_copy = copy.deepcopy(self._ag.tab_alarms)
TestCase = namedtuple('TestCase', ['name', 'input', 'output'])
TestInput = namedtuple('TestInput', ['alarm_ack_req'])
TestOutput = namedtuple('TestOutput', ['return_code', 'alarm_send',
'ack_values'])
tests = [
TestCase(
name='case 1: Invalid "table"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='invalid_table',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 2: Invalid "name"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='invalid_name', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 3: Invalid "type"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='invalid_type',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.ALARM_NOT_PRESENT,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 4: Invalid "timestamp"',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=UTCTimestampUsec())),
output=TestOutput(
return_code=\
SandeshAlarmAckResponseCode.INVALID_ALARM_REQUEST,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 5: Valid ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':False, 'type2':True})
),
TestCase(
name='case 6: Duplicate ack request',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type2',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type2').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=False, ack_values=None)
),
TestCase(
name='case 7: Valid ack request - different alarm type',
input=TestInput(
alarm_ack_req=SandeshAlarmAckRequest(table='table1',
name='name1', type='type1',
timestamp=self.get_test_alarm(
'table1', 'name1', 'type1').timestamp)),
output=TestOutput(
return_code=SandeshAlarmAckResponseCode.SUCCESS,
alarm_send=True, ack_values={'type1':True, 'type2':True})
)
]
for case in tests:
logging.info('=== Test %s ===' % (case.name))
return_code = self._ag.alarm_ack_callback(case.input.alarm_ack_req)
# verify return code
self.assertEqual(case.output.return_code, return_code)
table = case.input.alarm_ack_req.table
name = case.input.alarm_ack_req.name
if case.output.alarm_send is True:
# verify alarm ack message is sent
uvekey = table+':'+name
for atype, alarm in tab_alarms_copy[table][uvekey].iteritems():
if atype in case.output.ack_values:
alarm.ack = case.output.ack_values[atype]
alarms = copy.deepcopy(tab_alarms_copy[table][uvekey])
alarm_data = UVEAlarms(name=name, alarms=alarms.values())
MockAlarmTrace.assert_called_once_with(data=alarm_data,
table=table, sandesh=self._ag._sandesh)
MockAlarmTrace().send.assert_called_once_with(
sandesh=self._ag._sandesh)
MockAlarmTrace.reset_mock()
else:
self.assertFalse(MockAlarmTrace.called)
# verify the alarm table after every call to alarm_ack_callback.
# verify that ack field is set in the alarm table upon
# successful acknowledgement and the table is untouched in case
# of failure.
self.assertEqual(tab_alarms_copy, self._ag.tab_alarms)
class TestAlarmGen(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls._pc = mock.patch('opserver.alarmgen.PartitionClient',
autospec=True)
cls._pc.start()
cls._dc = mock.patch('opserver.alarmgen.client.DiscoveryClient',
autospec=True)
cls._dc.start()
cls._kc = mock.patch('opserver.partition_handler.KafkaClient',
autospec=True)
cls._kc.start()
@classmethod
def tearDownClass(cls):
cls._dc.stop()
cls._pc.stop()
cls._kc.stop()
def setUp(self):
config = CfgParser('--http_server_port 0 '
'--zk_list 127.0.0.1:0 '
'--disc_server_ip 127.0.0.1 '
'--redis_server_port 0')
config.parse()
self._ag = Controller(config, logging)
self._agtask = gevent.spawn(self._ag.run_uve_processing)
def tearDown(self):
self._agtask.kill()
@retry(delay=1, tries=3)
def checker_dict(self, expected, actual, match=True):
residual = actual
matched = True
result = False
for elem in expected:
if elem in residual:
residual = residual[elem]
else:
matched = False
if match:
result = matched
else:
result = not matched
if not result:
logging.info("exp %s actual %s match %s" % \
(str(expected), str(actual), str(match)))
return result
@retry(delay=1, tries=3)
def checker_exact(self, expected, actual, match=True):
result = False
if expected == actual:
return match
else:
result = not match
if not result:
logging.info("exp %s actual %s match %s" % \
(str(expected), str(actual), str(match)))
return result
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test partition Initialization, including boot-straping using UVEServer
# Test partition shutdown as well
def test_00_init(self, mock_SimpleConsumer, mock_get_uve, mock_get_part):
m_get_part = Mock_get_part()
m_get_part[(1, ("127.0.0.1", 0, 0))] = {
"127.0.0.1:0": {
"gen1": {
"ObjectXX:uve1": set(["type1"])
}
}
}
mock_get_part.side_effect = m_get_part
m_get_uve = Mock_get_uve()
m_get_uve["ObjectXX:uve1"] = {"type1": {"xx": 0}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectXX"]["uve1"].values(), {"type1" : {"xx": 0}}))
# Shutdown partition
self._ag.libpart_cb([])
self.assertTrue(self.checker_dict([1, "ObjectXX", "uve1"],\
self._ag.ptab_info, False))
@mock.patch.object(UVEServer, 'get_part')
@mock.patch.object(UVEServer, 'get_uve')
@mock.patch('opserver.partition_handler.SimpleConsumer', autospec=True)
# Test initialization followed by read from Kafka
# Also test for deletetion of a boot-straped UVE
def test_01_rxmsg(self, mock_SimpleConsumer, mock_get_uve, mock_get_part):
m_get_part = Mock_get_part()
m_get_part[(1, ("127.0.0.1", 0, 0))] = {
"127.0.0.1:0": {
"gen1": {
"ObjectXX:uve1": set(["type1"])
}
}
}
mock_get_part.side_effect = m_get_part
# Boostraped UVE ObjectXX:uve1 is not present!
m_get_uve = Mock_get_uve()
m_get_uve["ObjectYY:uve2"] = {"type2": {"yy": 1}}
mock_get_uve.side_effect = m_get_uve
m_get_messages = Mock_get_messages()
m_get_messages["ObjectYY:uve2"] = OffsetAndMessage(
offset=0,
message=Message(
magic=0,
attributes=0,
key='',
value=('{"message":"UVEUpdate","key":"ObjectYY:uve2",'
'"type":"type2","gen":"gen1","coll":'
'"127.0.0.1:0","deleted":false}')))
mock_SimpleConsumer.return_value.get_messages.side_effect = \
m_get_messages
self._ag.disc_cb_coll([{"ip-address": "127.0.0.1", "pid": 0}])
self._ag.libpart_cb([1])
self.assertTrue(
self.checker_dict([1, "ObjectXX", "uve1"], self._ag.ptab_info,
False))
self.assertTrue(
self.checker_dict([1, "ObjectYY", "uve2"], self._ag.ptab_info))
self.assertTrue(self.checker_exact(\
self._ag.ptab_info[1]["ObjectYY"]["uve2"].values(), {"type2" : {"yy": 1}}))
