def test_no_mapping(self, register_mock, result_mock, Popen_mock):
result_mock.return_value = {
'reports': [{'status': 'IN_PROGRESS',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 777}],
'componentStatus': [{'status': 'HEALTHY', 'componentName': 'NAMENODE'}]
}
config = AmbariConfig.AmbariConfig()
config.set('agent', 'prefix', 'tmp')
config.set('agent', 'cache_dir', "/var/lib/ambari-agent/cache")
config.set('agent', 'tolerate_download_failures', "true")
dummy_controller = MagicMock()
actionQueue = ActionQueue(config, dummy_controller)
heartbeat = Heartbeat(actionQueue)
hb = heartbeat.build(id = 10, state_interval=1, componentsMapped=True)
self.assertEqual(register_mock.call_args_list[0][0][1], True)
register_mock.reset_mock()
hb = heartbeat.build(id = 0, state_interval=1, componentsMapped=True)
self.assertEqual(register_mock.call_args_list[0][0][1], False)
def test_heartbeat_no_host_check_cmd_in_queue(self, register_mock,
Popen_mock):
config = AmbariConfig.AmbariConfig()
config.set('agent', 'prefix', 'tmp')
config.set('agent', 'cache_dir', "/var/lib/ambari-agent/cache")
config.set('agent', 'tolerate_download_failures', "true")
dummy_controller = MagicMock()
actionQueue = ActionQueue(config, dummy_controller)
statusCommand = {
"serviceName": 'HDFS',
"commandType": "STATUS_COMMAND",
"clusterName": "c1",
"componentName": "DATANODE",
"role": "DATANODE",
'configurations': {
'global': {}
}
}
actionQueue.put_status([statusCommand])
heartbeat = Heartbeat(actionQueue)
heartbeat.build(12, 6)
self.assertTrue(register_mock.called)
args, kwargs = register_mock.call_args_list[0]
self.assertFalse(args[2])
self.assertFalse(args[1])
def test_build(self):
config = AmbariConfig.AmbariConfig()
config.set('agent', 'prefix', 'tmp')
config.set('agent', 'cache_dir', "/var/lib/ambari-agent/cache")
config.set('agent', 'tolerate_download_failures', "true")
dummy_controller = MagicMock()
actionQueue = ActionQueue(config, dummy_controller)
heartbeat = Heartbeat(actionQueue)
result = heartbeat.build(100)
print "Heartbeat: " + str(result)
self.assertEquals(result['hostname'] != '', True,
"hostname should not be empty")
self.assertEquals(result['responseId'], 100)
self.assertEquals(result['componentStatus'] is not None, True,
"Heartbeat should contain componentStatus")
self.assertEquals(result['reports'] is not None, True,
"Heartbeat should contain reports")
self.assertEquals(result['timestamp'] >= 1353679373880L, True)
self.assertEquals(len(result['nodeStatus']), 2)
self.assertEquals(result['nodeStatus']['cause'], "NONE")
self.assertEquals(result['nodeStatus']['status'], "HEALTHY")
# result may or may NOT have an agentEnv structure in it
self.assertEquals((len(result) is 6) or (len(result) is 7), True)
self.assertEquals(not heartbeat.reports, True,
"Heartbeat should not contain task in progress")
def test_heartbeat_with_task_in_progress(self):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
actionQueue.commandInProgress = {
'role': "role",
'actionId': "actionId",
'taskId': "taskId",
'stdout': "stdout",
'clusterName': "clusterName",
'stderr': 'none',
'exitCode': 777,
'serviceName': "serviceName",
'status': 'IN_PROGRESS',
'configurations': {
'global': {}
},
'roleCommand': 'START'
}
heartbeat = Heartbeat(actionQueue)
result = heartbeat.build(100)
#print "Heartbeat: " + str(result)
self.assertEquals(len(result['reports']), 1)
self.assertEquals(result['reports'][0]['role'], "role")
self.assertEquals(result['reports'][0]['actionId'], "actionId")
self.assertEquals(result['reports'][0]['taskId'], "taskId")
self.assertEquals(result['reports'][0]['stdout'], "...")
self.assertEquals(result['reports'][0]['clusterName'], "clusterName")
self.assertEquals(result['reports'][0]['stderr'], "...")
self.assertEquals(result['reports'][0]['exitCode'], 777)
self.assertEquals(result['reports'][0]['serviceName'], "serviceName")
self.assertEquals(result['reports'][0]['status'], "IN_PROGRESS")
self.assertEquals(result['reports'][0]['roleCommand'], "START")
pass
def test_heartbeat_with_status_multiple(self, read_stack_version_method):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
actionQueue.IDLE_SLEEP_TIME = 0.01
read_stack_version_method.return_value = "1.3.0"
heartbeat = Heartbeat(actionQueue)
actionQueue.start()
max_number_of_status_entries = 0
for i in range(1, 5):
statusCommand = {
"serviceName": 'HDFS',
"commandType": "STATUS_COMMAND",
"clusterName": "",
"componentName": "DATANODE",
'configurations': {
'global': {}
}
}
actionQueue.put(statusCommand)
time.sleep(0.1)
result = heartbeat.build(101)
number_of_status_entries = len(result['componentStatus'])
# print "Heartbeat with status: " + str(result) + " XXX " + str(number_of_status_entries)
if max_number_of_status_entries < number_of_status_entries:
max_number_of_status_entries = number_of_status_entries
actionQueue.stop()
actionQueue.join()
NUMBER_OF_COMPONENTS = 1
self.assertEquals(max_number_of_status_entries == NUMBER_OF_COMPONENTS,
True)
def test_build(self):
testsPath = os.path.dirname(os.path.realpath(__file__))
dictPath = testsPath + os.sep + '..' + os.sep + '..' + os.sep + 'main' + os.sep + 'python' + os.sep + 'ambari_agent' + os.sep + 'servicesToPidNames.dict'
AmbariConfig.config.set('services', 'serviceToPidMapFile', dictPath)
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
heartbeat = Heartbeat(actionQueue)
result = heartbeat.build(100)
def test_no_mapping(self, register_mock, result_mock):
result_mock.return_value = {
'reports': [{
'status': 'IN_PROGRESS',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 777
}],
'componentStatus': [{
'status': 'HEALTHY',
'componentName': 'NAMENODE'
}]
}
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig(),
'dummy_controller')
heartbeat = Heartbeat(actionQueue)
hb = heartbeat.build(id=10, state_interval=1, componentsMapped=True)
self.assertEqual(register_mock.call_args_list[0][0][1], True)
register_mock.reset_mock()
hb = heartbeat.build(id=0, state_interval=1, componentsMapped=True)
self.assertEqual(register_mock.call_args_list[0][0][1], False)
def test_heartbeat_host_check_no_cmd(self, register_mock):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
heartbeat = Heartbeat(actionQueue)
heartbeat.build(12, 6)
self.assertTrue(register_mock.called)
args, kwargs = register_mock.call_args_list[0]
self.assertFalse(args[1])
self.assertFalse(args[2])
def test_heartbeat_host_check_no_cmd(self, register_mock, Popen_mock):
config = AmbariConfig.AmbariConfig()
config.set('agent', 'prefix', 'tmp')
config.set('agent', 'cache_dir', "/var/lib/ambari-agent/cache")
config.set('agent', 'tolerate_download_failures', "true")
dummy_controller = MagicMock()
actionQueue = ActionQueue(config, dummy_controller)
heartbeat = Heartbeat(actionQueue)
heartbeat.build(12, 6)
self.assertTrue(register_mock.called)
args, kwargs = register_mock.call_args_list[0]
self.assertFalse(args[1])
self.assertFalse(args[2])
def test_heartbeat_no_host_check_cmd_in_queue(self, register_mock):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
statusCommand = {
"serviceName": 'HDFS',
"commandType": "STATUS_COMMAND",
"clusterName": "",
"componentName": "DATANODE",
'configurations': {
'global': {}
}
}
actionQueue.commandQueue.put(statusCommand)
heartbeat = Heartbeat(actionQueue)
heartbeat.build(12, 6)
self.assertTrue(register_mock.called)
args, kwargs = register_mock.call_args_list[0]
self.assertTrue(args[2])
self.assertFalse(args[1])
def test_build(self):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
heartbeat = Heartbeat(actionQueue)
result = heartbeat.build(100)
print "Heartbeat: " + str(result)
self.assertEquals(result['hostname'] != '', True,
"hostname should not be empty")
self.assertEquals(result['responseId'], 100)
self.assertEquals(result['componentStatus'] is not None, True,
"Heartbeat should contain componentStatus")
self.assertEquals(result['reports'] is not None, True,
"Heartbeat should contain reports")
self.assertEquals(result['timestamp'] >= 1353679373880L, True)
self.assertEquals(len(result['nodeStatus']), 2)
self.assertEquals(result['nodeStatus']['cause'], "NONE")
self.assertEquals(result['nodeStatus']['status'], "HEALTHY")
# result may or may NOT have an agentEnv structure in it
self.assertEquals((len(result) is 6) or (len(result) is 7), True)
self.assertEquals(not heartbeat.reports, True,
"Heartbeat should not contain task in progress")
def test_heartbeat_with_status(self, read_stack_version_method):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
read_stack_version_method.return_value = "1.3.0"
heartbeat = Heartbeat(actionQueue)
statusCommand = {
"serviceName": 'HDFS',
"commandType": "STATUS_COMMAND",
"clusterName": "",
"componentName": "DATANODE",
'configurations': {
'global': {}
}
}
actionQueue.put(statusCommand)
actionQueue.start()
time.sleep(0.1)
actionQueue.stop()
actionQueue.join()
result = heartbeat.build(101)
self.assertEquals(
len(result['componentStatus']) > 0, True,
'Heartbeat should contain status of HDFS components')
def test_heartbeat_retries(self):
netutil = NetUtil()
netutil.HEARTBEAT_IDDLE_INTERVAL_SEC = 0.05
netutil.HEARTBEAT_NOT_IDDLE_INTERVAL_SEC = 0.05
#building heartbeat object
testsPath = os.path.dirname(os.path.realpath(__file__))
dictPath = testsPath + os.sep + '..' + os.sep + '..' + os.sep + 'main' + os.sep + 'python' + os.sep + 'ambari_agent' + os.sep + 'servicesToPidNames.dict'
AmbariConfig.config.set('services', 'serviceToPidMapFile', dictPath)
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
heartbeat = Heartbeat(actionQueue)
# testing controller with our heartbeat and wrong url
controller = Controller(AmbariConfig.config)
controller.heartbeat = heartbeat
controller.heartbeatUrl = BAD_URL
controller.actionQueue = actionQueue
controller.logger = self.logger
controller.netutil = netutil
thread = Thread(target=controller.heartbeatWithServer)
thread.start()
time.sleep(1)
# I have to stop the thread anyway, so I'll check results later
threadWasAlive = thread.isAlive()
successfull_heartbits0 = controller.DEBUG_SUCCESSFULL_HEARTBEATS
heartbeat_retries0 = controller.DEBUG_HEARTBEAT_RETRIES
# Stopping thread
controller.DEBUG_STOP_HEARTBITTING = True
time.sleep(1)
# Checking results before thread stop
self.assertEquals(threadWasAlive, True,
"Heartbeat should be alive now")
self.assertEquals(successfull_heartbits0, 0,
"Heartbeat should not have any success")
self.assertEquals(heartbeat_retries0 > 1, True,
"Heartbeat should retry connecting")
# Checking results after thread stop
self.assertEquals(thread.isAlive(), False, "Heartbeat should stop now")
self.assertEquals(controller.DEBUG_SUCCESSFULL_HEARTBEATS, 0,
"Heartbeat should not have any success")
def test_heartbeat_no_host_check_cmd_in_progress(self, register_mock):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig())
actionQueue.commandInProgress = {
'role': "role",
'actionId': "actionId",
'taskId': "taskId",
'stdout': "stdout",
'clusterName': "clusterName",
'stderr': 'none',
'exitCode': 777,
'serviceName': "serviceName",
'status': 'IN_PROGRESS',
'configurations': {
'global': {}
},
'roleCommand': 'START'
}
heartbeat = Heartbeat(actionQueue)
heartbeat.build(12, 6)
self.assertTrue(register_mock.called)
args, kwargs = register_mock.call_args_list[0]
self.assertTrue(args[2])
self.assertFalse(args[1])
def test_build_long_result(self, result_mock):
config = AmbariConfig.AmbariConfig()
config.set('agent', 'prefix', 'tmp')
config.set('agent', 'cache_dir', "/var/lib/ambari-agent/cache")
config.set('agent', 'tolerate_download_failures', "true")
dummy_controller = MagicMock()
dummy_controller.recovery_manager = RecoveryManager(tempfile.mktemp())
actionQueue = ActionQueue(config, dummy_controller)
result_mock.return_value = {
'reports': [{'status': 'IN_PROGRESS',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 777},
{'status': 'COMPLETED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': 'clusterName',
'roleCommand': 'UPGRADE',
'serviceName': 'serviceName',
'role': 'role',
'actionId': 17,
'taskId': 'taskId',
'exitCode': 0},
{'status': 'FAILED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 13},
{'status': 'COMPLETED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': u'cc',
'configurationTags': {'global': {'tag': 'v1'}},
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 0}
],
'componentStatus': [
{'status': 'HEALTHY', 'componentName': 'DATANODE'},
{'status': 'UNHEALTHY', 'componentName': 'NAMENODE'},
],
}
heartbeat = Heartbeat(actionQueue)
hb = heartbeat.build(10)
hb['hostname'] = 'hostname'
hb['timestamp'] = 'timestamp'
expected = {'nodeStatus':
{'status': 'HEALTHY',
'cause': 'NONE'},
'recoveryReport': {'summary': 'DISABLED'},
'recoveryTimestamp': -1,
'timestamp': 'timestamp', 'hostname': 'hostname',
'responseId': 10, 'reports': [
{'status': 'IN_PROGRESS', 'roleCommand': u'INSTALL',
'serviceName': u'HDFS', 'role': u'DATANODE', 'actionId': '1-1',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt', 'clusterName': u'cc',
'taskId': 3, 'exitCode': 777},
{'status': 'COMPLETED', 'roleCommand': 'UPGRADE',
'serviceName': 'serviceName', 'role': 'role', 'actionId': 17,
'stderr': 'stderr', 'stdout': 'out', 'clusterName': 'clusterName',
'taskId': 'taskId', 'exitCode': 0},
{'status': 'FAILED', 'roleCommand': u'INSTALL', 'serviceName': u'HDFS',
'role': u'DATANODE', 'actionId': '1-1', 'stderr': 'stderr',
'stdout': 'out', 'clusterName': u'cc', 'taskId': 3, 'exitCode': 13},
{'status': 'COMPLETED', 'stdout': 'out',
'configurationTags': {'global': {'tag': 'v1'}}, 'taskId': 3,
'exitCode': 0, 'roleCommand': u'INSTALL', 'clusterName': u'cc',
'serviceName': u'HDFS', 'role': u'DATANODE', 'actionId': '1-1',
'stderr': 'stderr'}], 'componentStatus': [
{'status': 'HEALTHY', 'componentName': 'DATANODE'},
{'status': 'UNHEALTHY', 'componentName': 'NAMENODE'}]}
self.assertEqual.__self__.maxDiff = None
self.assertEquals(hb, expected)
def test_build_long_result(self, result_mock):
actionQueue = ActionQueue(AmbariConfig.AmbariConfig().getConfig(),
'dummy_controller')
result_mock.return_value = {
'reports': [{
'status': 'IN_PROGRESS',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 777
}, {
'status': 'COMPLETED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': 'clusterName',
'roleCommand': 'UPGRADE',
'serviceName': 'serviceName',
'role': 'role',
'actionId': 17,
'taskId': 'taskId',
'exitCode': 0
}, {
'status': 'FAILED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': u'cc',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 13
}, {
'status': 'COMPLETED',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': u'cc',
'configurationTags': {
'global': {
'tag': 'v1'
}
},
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'taskId': 3,
'exitCode': 0
}],
'componentStatus': [
{
'status': 'HEALTHY',
'componentName': 'DATANODE'
},
{
'status': 'UNHEALTHY',
'componentName': 'NAMENODE'
},
],
}
heartbeat = Heartbeat(actionQueue)
hb = heartbeat.build(10)
hb['hostname'] = 'hostname'
hb['timestamp'] = 'timestamp'
expected = {
'nodeStatus': {
'status': 'HEALTHY',
'cause': 'NONE'
},
'timestamp':
'timestamp',
'hostname':
'hostname',
'responseId':
10,
'reports': [{
'status': 'IN_PROGRESS',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'stderr': 'Read from /tmp/errors-3.txt',
'stdout': 'Read from /tmp/output-3.txt',
'clusterName': u'cc',
'taskId': 3,
'exitCode': 777
}, {
'status': 'COMPLETED',
'roleCommand': 'UPGRADE',
'serviceName': 'serviceName',
'role': 'role',
'actionId': 17,
'stderr': 'stderr',
'stdout': 'out',
'clusterName': 'clusterName',
'taskId': 'taskId',
'exitCode': 0
}, {
'status': 'FAILED',
'roleCommand': u'INSTALL',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'stderr': 'stderr',
'stdout': 'out',
'clusterName': u'cc',
'taskId': 3,
'exitCode': 13
}, {
'status': 'COMPLETED',
'stdout': 'out',
'configurationTags': {
'global': {
'tag': 'v1'
}
},
'taskId': 3,
'exitCode': 0,
'roleCommand': u'INSTALL',
'clusterName': u'cc',
'serviceName': u'HDFS',
'role': u'DATANODE',
'actionId': '1-1',
'stderr': 'stderr'
}],
'componentStatus': [{
'status': 'HEALTHY',
'componentName': 'DATANODE'
}, {
'status': 'UNHEALTHY',
'componentName': 'NAMENODE'
}]
}
self.assertEquals(hb, expected)
