def test_er_008_009_recording_recovery_manifest_restart_(
stream, name, copy_type):
"""
UNIQUE and COMMON copy Recording recovery
"""
web_service_objects = []
recording_pool = None
recording = None
total_recording = 20
diff_start_time_recordings = 10
same_start_time_recordings = 10
service_name = V2pc.MANIFEST_AGENT
namespace = Component.VMR
try:
#Taking backup of v2pc pod config info and editing the config and then restarting the services
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
is_valid, error = v2pc_edit_manifest_config(V2pc.MANIFEST_AGENT,
batch_size='4')
assert is_valid, error
is_valid, error = verify_batch_size_update(service_name, namespace,
"4")
assert is_valid, error
queue = Queue.Queue()
start_time = utils.get_formatted_time(constants.SECONDS * 30,
TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time(constants.SECONDS * 150,
TimeFormat.TIME_FORMAT_MS, stream)
recording = recording_model.Recording(
total_recordings=same_start_time_recordings,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
for i in range(diff_start_time_recordings, same_start_time_recordings +
diff_start_time_recordings):
start_time = utils.get_formatted_time((constants.SECONDS * 30) + i,
TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time((constants.SECONDS * 150) + i,
TimeFormat.TIME_FORMAT_MS,
stream)
rec_with_diff_time = recording_model.Recording(
total_recordings=1,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
rec_with_diff_time.Entries[0].RecordingId = RecordingAttribute.RECORDING_ID_PREFIX + \
rec_with_diff_time.RequestId + '_' + str(i)
recording.Entries.append(rec_with_diff_time.get_entry(0))
last_recording_id = rec_with_diff_time.Entries[0].RecordingId
for i in range(total_recording):
recording_id = recording.get_entry(i).RecordingId
web_service_objects.append(
notification_utils.get_web_service_object(recording_id))
recording.get_entry(i).UpdateUrl = web_service_objects[i].get_url()
LOGGER.debug("Recording instance created=%s", recording.serialize())
#Sending recording request to create recording
response = a8.create_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response, requests.codes.no_content)
assert is_valid, error
response = rio.find_recording(last_recording_id).json()
if not response:
return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(
last_recording_id)
start_time = utils.get_parsed_time(
response[0][RecordingAttribute.START_TIME][:-1])
current_time = datetime.datetime.utcnow()
wait_time = utils.add_time_to_secs((start_time - current_time),
constants.SECONDS)
if wait_time < 0:
wait_time = 0
#Verifying recording is started or not
recording_pool = mp_pool.ThreadPool()
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_notification,
(web_service_objects[i], constants.RecordingStatus.STARTED,
wait_time),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
is_valid, error = delete_vmr_pods(V2pc.MANIFEST_AGENT)
assert is_valid, error
response = rio.find_recording(last_recording_id).json()
if not response:
return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(
last_recording_id)
end_time = utils.get_parsed_time(
response[0][RecordingAttribute.END_TIME][:-1])
current_time = datetime.datetime.utcnow()
wait_time = utils.add_time_to_secs((end_time - current_time),
constants.SECONDS)
if wait_time < 0:
wait_time = 0
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_notification,
(web_service_objects[i], constants.RecordingStatus.COMPLETE,
wait_time),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
#Verifying recording in storage
for i in range(total_recording):
response = rio.find_recording(
recording.get_entry(i).RecordingId).json()
is_valid, error = validate_storage.validate_recording_in_storage(
response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED)
assert is_valid, error
#Verfying Archive storage
archive_helper.wait_for_archival(stream,
recording.get_entry(0).RecordingId,
Archive.ARCHIVE, Archive.COMPLETE)
for i in range(total_recording):
response = rio.find_recording(
recording.get_entry(i).RecordingId).json()
is_valid, error = validate_storage.validate_recording_in_storage(
response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED)
assert is_valid, error
is_valid, error = validate_storage.validate_copy_count(
response, Cos.ARCHIVE_STORAGE)
assert is_valid, error
finally:
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
if recording_pool:
recording_pool.close()
recording_pool.join()
for web_service_obj in web_service_objects:
web_service_obj.stop_server()
if recording:
response = a8.delete_recording(recording)
LOGGER.debug("Recording clean up status code=%s",
response.status_code)
def test_rtc9758_tc_rec_012_IPDVRTESTS_52_delete_and_playback_after_recording_start(
recording_start_delay, stream):
"""
Create a recording, delete and play it back after it starts
"""
recording = None
web_service_obj = None
try:
start_time = utils.get_formatted_time(
constants.SECONDS * recording_start_delay,
TimeFormat.TIME_FORMAT_MS, stream)
end_time = utils.get_formatted_time(constants.SECONDS * 60,
TimeFormat.TIME_FORMAT_MS, stream)
recording = recording_model.Recording(StartTime=start_time,
EndTime=end_time,
StreamId=stream)
recording_id = recording.get_entry(0).RecordingId
web_service_obj = notification_utils.get_web_service_object(
recording_id)
recording.get_entry(0).UpdateUrl = web_service_obj.get_url()
LOGGER.debug("Recording instance created=%s", recording.serialize())
response = a8.create_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response, requests.codes.no_content)
assert is_valid, error
recording_id = recording.get_entry(0).RecordingId
response = rio.find_recording(recording_id).json()
LOGGER.debug("Response=%s", response)
start_time = utils.get_parsed_time(
response[0][RecordingAttribute.START_TIME][:-1])
current_time = datetime.datetime.utcnow()
# wait till the recording start time
if current_time < start_time:
utils.wait(start_time - current_time, constants.TIME_DELTA)
is_valid, error = validate_recordings.validate_notification(
web_service_obj, constants.RecordingStatus.STARTED)
assert is_valid, error
time.sleep(15 * constants.SECONDS)
delete_time = utils.get_formatted_time(constants.SECONDS * 0,
TimeFormat.TIME_FORMAT_MS,
stream)
response = a8.delete_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response, requests.codes.no_content)
assert is_valid, error
is_valid, error = validate_recordings.validate_recording_deletion(
recording_id)
assert is_valid, error
is_valid, error = validate_recordings.validate_playback_using_vle(
recording_id, EndTime=delete_time)
assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format(
recording_id)
finally:
web_service_obj.stop_server()
response = a8.delete_recording(recording)
LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9725_tc_change_batch_size_multiple(stream, name, copy_type):
"""
Schedule UNIQUE copy recording (20 - 10 same start/end time, 10 different start/end times), batch size 4.
"""
web_service_objects = []
recording_pool = None
recording = None
total_recording = 20
diff_start_time_recordings = 10
same_start_time_recordings = 10
service_name = V2pc.MANIFEST_AGENT
namespace = Component.VMR
try:
#Taking backup of v2pc pod config info, editing the config and then restarting the services
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
is_valid, error = v2pc_edit_manifest_config(V2pc.MANIFEST_AGENT,
batch_size='4')
assert is_valid, error
is_valid, error = verify_batch_size_update(service_name, namespace,
"4")
assert is_valid, error
queue = Queue.Queue()
start_time = utils.get_formatted_time(constants.SECONDS * 30,
TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time(constants.SECONDS * 90,
TimeFormat.TIME_FORMAT_MS, stream)
recording = recording_model.Recording(
total_recordings=same_start_time_recordings,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
for i in range(diff_start_time_recordings, same_start_time_recordings +
diff_start_time_recordings):
start_time = utils.get_formatted_time((constants.SECONDS * 30) + i,
TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time((constants.SECONDS * 90) + i,
TimeFormat.TIME_FORMAT_MS,
stream)
rec_with_diff_time = recording_model.Recording(
total_recordings=1,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
rec_with_diff_time.Entries[
0].RecordingId = RecordingAttribute.RECORDING_ID_PREFIX + rec_with_diff_time.RequestId + '_' + str(
i)
recording.Entries.append(rec_with_diff_time.get_entry(0))
last_recording_id = rec_with_diff_time.Entries[0].RecordingId
for i in range(total_recording):
recording_id = recording.get_entry(i).RecordingId
web_service_objects.append(
notification_utils.get_web_service_object(recording_id))
recording.get_entry(i).UpdateUrl = web_service_objects[i].get_url()
LOGGER.debug("Recording instance created=%s", recording.serialize())
#Sending recording request to create recording
response = a8.create_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response, requests.codes.no_content)
assert is_valid, error
response = rio.find_recording(last_recording_id).json()
if not response:
return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(
last_recording_id)
start_time = utils.get_parsed_time(
response[0][RecordingAttribute.START_TIME][:-1])
current_time = datetime.datetime.utcnow()
wait_time = utils.add_time_to_secs((start_time - current_time),
constants.SECONDS)
if wait_time < 0:
wait_time = 0
#Verifying recording is started or not
recording_pool = mp_pool.ThreadPool()
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_notification,
(web_service_objects[i], constants.RecordingStatus.STARTED,
wait_time),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
#Verifying playback of recording in progress
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_vle,
(recording.get_entry(i).RecordingId, ),
dict(in_progress=True),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_hls_checker,
(recording.get_entry(i).RecordingId, ),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
#Verifying recording is completed or not
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_notification,
(web_service_objects[i], constants.RecordingStatus.COMPLETE),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
#Playback verification after recording completed
for i in range(total_recording):
recording_pool.apply_async(validate_recordings.validate_playback,
(recording.get_entry(i).RecordingId, ),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
finally:
#Revert back the v2pc config changes
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
if recording_pool:
recording_pool.close()
recording_pool.join()
for web_service_obj in web_service_objects:
if web_service_obj:
web_service_obj.stop_server()
if recording:
response = a8.delete_recording(recording)
LOGGER.debug("Recording clean up status code=%s",
response.status_code)
def test_er_003_004_recording_incomplete(stream, name, copy_type):
"""
Create multiple recordings with copy type as COMMON
"""
web_service_objects = []
recording_pool = None
recording = None
total_recording = 20
diff_start_time_recordings = 10
same_start_time_recordings = 10
recording_duration = 30 # in sec
response_a8 = None
service_name = V2pc.MANIFEST_AGENT
namespace = Component.VMR
try:
# backup v2pc master config
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
is_valid, error = v2pc_edit_manifest_config(V2pc.MANIFEST_AGENT,
batch_size='4')
assert is_valid, error
is_valid, error = verify_batch_size_update(service_name, namespace,
"4")
assert is_valid, error
queue = Queue.Queue()
start_time = utils.get_formatted_time(
constants.SECONDS * recording_duration, TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time(
constants.SECONDS * recording_duration * 5,
TimeFormat.TIME_FORMAT_MS, stream)
# same start time 10 recordings
recording = recording_model.Recording(
total_recordings=same_start_time_recordings,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
# different start time 10 recordings
for i in range(diff_start_time_recordings, same_start_time_recordings +
diff_start_time_recordings):
start_time = utils.get_formatted_time(
(constants.SECONDS * recording_duration) + i,
TimeFormat.TIME_FORMAT_MS, stream)
end_time = utils.get_formatted_time(
(constants.SECONDS * recording_duration * 5) + i,
TimeFormat.TIME_FORMAT_MS, stream)
rec_with_diff_time = recording_model.Recording(
total_recordings=diff_start_time_recordings,
StartTime=start_time,
EndTime=end_time,
copyType=copy_type,
StreamId=stream)
rec_with_diff_time.Entries[0].RecordingId = RecordingAttribute.RECORDING_ID_PREFIX + \
rec_with_diff_time.RequestId + '_' + str(i)
recording.Entries.append(rec_with_diff_time.get_entry(0))
last_recording_id = rec_with_diff_time.Entries[0].RecordingId
# get recording id and update url
for i in range(total_recording):
recording_id = recording.get_entry(i).RecordingId
web_service_objects.append(
notification_utils.get_web_service_object(recording_id))
recording.get_entry(i).UpdateUrl = web_service_objects[i].get_url()
# create recording
LOGGER.debug("Recording instance created=%s", recording.serialize())
response_a8 = a8.create_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response_a8, requests.codes.no_content)
assert is_valid, error
response = rio.find_recording(last_recording_id).json()
if not response:
return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(
last_recording_id)
start_time = utils.get_parsed_time(
response[0][RecordingAttribute.START_TIME][:-1])
current_time = datetime.datetime.utcnow()
wait_time = utils.add_time_to_secs((start_time - current_time),
constants.SECONDS)
if wait_time < 0:
wait_time = 0
# validate recording is started
recording_pool = mp_pool.ThreadPool()
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_notification,
(web_service_objects[i], constants.RecordingStatus.STARTED,
wait_time),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
#restarting segment recorder to make INCOMPLETE recording
is_valid, error = delete_vmr_pods(V2pc.SEGMENT_RECORDER)
assert is_valid, error
# validate playback using vle
# verify recording in progress
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_vle,
(recording.get_entry(i).RecordingId, ),
dict(in_progress=True),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
# validate playback using hls checker while recording is in progress
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_hls_checker,
(recording.get_entry(i).RecordingId, ),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
if not is_valid:
assert 'discontinuity' in error, error
#Verifying recording INCOMPLETE STATE
for i in range(total_recording):
recording_id = recording.get_entry(i).RecordingId
recording_pool.apply_async(
validate_recordings.validate_recording_end_state,
(recording_id, [constants.RecordingStatus.INCOMPLETE]),
dict(web_service_obj=web_service_objects[i],
end_time=end_time),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
# Playback using VLE
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_vle,
(recording.get_entry(i).RecordingId, ),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
assert is_valid, error
# Playback using hls checker
for i in range(total_recording):
recording_pool.apply_async(
validate_recordings.validate_playback_using_hls_checker,
(recording.get_entry(i).RecordingId, ),
callback=queue.put)
for i in range(total_recording):
is_valid, error = queue.get()
if not is_valid:
assert 'discontinuity' in error, error
finally:
is_valid, error = cleanup(redeploy_config_map,
service_name,
revert=True)
assert is_valid, error
if recording_pool:
recording_pool.close()
recording_pool.join()
for web_service_obj in web_service_objects:
if web_service_obj:
web_service_obj.stop_server()
if response_a8:
response = a8.delete_recording(recording)
LOGGER.debug("Recording clean up status code=%s",
response.status_code)
def test_schedule_recording_ipdvrtests_47(stream):
"""
JIRA_URL : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-47
DESCRIPTION : Schedule recording(future timing)
"""
web_service_obj = None
recording = None
try:
# STEP 1: Create recording
LOGGER.info("Creating Recording")
rec_buffer_time = utils.get_rec_duration(
dur_confg_key=Component.REC_BUFFER_LEN_IN_SEC)
rec_duration = utils.get_rec_duration(
dur_confg_key=Component.SHORT_REC_LEN_IN_SEC)
start_time = utils.get_formatted_time(
(constants.SECONDS * rec_buffer_time), TimeFormat.TIME_FORMAT_MS,
stream)
end_time = utils.get_formatted_time(
(constants.SECONDS * (rec_buffer_time + rec_duration)),
TimeFormat.TIME_FORMAT_MS, stream)
recording = recording_model.Recording(StartTime=start_time,
EndTime=end_time,
StreamId=stream)
recording_id = recording.get_entry(0).RecordingId
web_service_obj = notification_utils.get_web_service_object(
recording_id)
recording.get_entry(0).UpdateUrl = web_service_obj.get_url()
LOGGER.debug("Recording instance created=%s", recording.serialize())
response = a8.create_recording(recording)
is_valid, error = validate_common.validate_http_response_status_code(
response, requests.codes.no_content)
assert is_valid, error
is_valid, error = validate_recordings.validate_recording(
recording_id, web_service_obj)
response = rio.find_recording(recording_id)
resp = json.loads(response.content)
#STEP 2: Check memsql table for recording start time using RIO API
LOGGER.info("Validate recording start time")
is_valid, error = validate_start_time(start_time, resp, stream)
assert is_valid, error
#STEP 3: Check cos logs to see segments are written by using COS API
LOGGER.info("Check segments in cos storage")
is_valid, error = validate_storage.validate_recording_in_storage(
resp, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED)
assert is_valid, error
#STEP 4: Check MA/SR pod logs for any errors while recording
LOGGER.info("Check MA/SR pod logs for any errors while recording")
s_time = utils.get_parsed_time(str(start_time)[:-1])
e_time = utils.get_parsed_time(str(end_time)[:-1])
is_valid, error = vmr_helper.verify_error_logs_in_vmr(
stream,
'manifest-agent',
'vmr',
search_string="ERROR",
start_time=s_time,
end_time=e_time)
assert is_valid, error
is_valid, error = vmr_helper.verify_error_logs_in_vmr(
stream,
'segment-recorder',
'vmr',
search_string="ERROR",
start_time=s_time,
end_time=e_time)
assert is_valid, error
#STEP 5: Check no discontinuity errors in MA
LOGGER.info("Check no discontinuity in MA")
is_valid, error = vmr_helper.verify_error_logs_in_vmr(
stream,
"manifest-agent",
"vmr",
search_string="discontinuity",
start_time=s_time,
end_time=e_time)
assert is_valid, error
#STEP 6: Check recording goes to complete state without any coredumps on MCE/ABRGW
LOGGER.info("Check core dumps")
is_valid, msg = utils.core_dump("mce")
assert is_valid, msg
finally:
if web_service_obj:
web_service_obj.stop_server()
if recording:
response = a8.delete_recording(recording)
LOGGER.debug("Recording clean up status code=%s",
response.status_code)