def test_rtc9734_tc_er_010_playback_redirect_mode(stream, name, copy_type): """ Playback of Active and Archive recording(UNIQUE and COMMON) with DO(Dash Origin) redirect enabled """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, 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, copyType=copy_type) 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) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error if copy_type == RecordingAttribute.COPY_TYPE_UNIQUE: archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).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_recordings.validate_playback( recording_id) assert is_valid, error 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)
def test_create_3hr_recording_ipdvrtests_64(channel, name, copy_type): """ JIRA_URL : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-64 DESCRIPTION : Create 3 hr recording #Partially automated Skipped step(s) : Step 3 - No errors seen in MA/SR pods """ stream = channel web_service_obj = None recording = None stream_name = nsa.get_stream(stream).json()[0][constants.STREAM_NAME] try: #STEP 1 - Create UC and CC recording with longer duration ~3hr start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 10830, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, 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 #STEP 2 - Verify recording state is complete is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error #Find recording LOGGER.info("Find recording in rio") response = rio.find_recording(recording_id).json() if not response: return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(recording_id) print "[INFO: ] Recording status in rio : ",response[0]['Status'] #Playback and Validate Playback LOGGER.info("Playback Recording") print "\nPlayback Recording" print "Recording ID :",recording.get_entry(0).RecordingId is_valid, error = validate_recordings.validate_playback(recording.get_entry(0).RecordingId) print "[INFO: ] ",is_valid assert is_valid, error #STEP 4 - memsql table has correct info for UC and CC LOGGER.info("Find recording in rio") response = rio.find_recording(recording_id).json() if not response: return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(recording_id) print "[INFO: ] Recording status in rio : \n" pprint (response, width=1) 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)
def test_rtc9762_tc_rec_016_multiple_unique(stream): """ Create multiple recordings with copy type as UNIQUE """ total_recordings = 3 web_service_objs = [] recording_pool = None recording = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append(notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].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_pool = mp_pool.ThreadPool(processes=total_recordings) for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objs[i]), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error for i in range(total_recordings): 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, i) assert is_valid, error for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_playback, (recording.get_entry(i).RecordingId,), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objs: 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_rtc9777_tc_arc_007_archive_playback_re_archive_unique(stream): """ Create a recording with copy type as UNIQUE, wait till archival completes, playback the recording and validate re-archival """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, 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 is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).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_recordings.validate_playback_using_vle(recording_id) assert is_valid, error 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_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.RE_ARCHIVE, Archive.COMPLETE) 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_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_NOT_STORED) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_des_016_vmr_ntp_out_of_sync(): LOGGER.info("vmr_ntp_out_of_sync test case...") recording = None web_service_obj = None timeout = int(os.environ.get(STREAM_ID)) ntp_server_v2pc = CONFIG_INFO[Component.V2PC][Component.NTP] india_ntp = '1.in.pool.ntp.org' ntp_synchronization_time = 300 # Initiate the recording try: start_time = utils.get_formatted_time((constants.SECONDS * 30) + timeout, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time((constants.SECONDS * 90) + timeout, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=STREAM_ID) 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 time.sleep(40) # Configure to the right ntp server in VMR cmd = "sed -i -E 's/" + ntp_server_v2pc + "/" + india_ntp + "/g' /etc/ntp.conf" update_vmr_ntp_server(cmd) time.sleep(ntp_synchronization_time) # Validate recording is incomplete is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) LOGGER.info(is_valid) LOGGER.info(error) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: # revert back the ntp to the original value in vmr cmd = "sed -i -E 's/" + india_ntp + "/" + ntp_server_v2pc + "/g' /etc/ntp.conf" update_vmr_ntp_server(cmd) time.sleep(ntp_synchronization_time) web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code) # Check whether all the components are synchronized. times_are_synchronized, error = test_setup.are_times_synchronized() if not times_are_synchronized: pytest.fail(error)
def test_rtc9750_tc_rec_002_future_start_time_future_end_time_common(stream): """ Create a recording with future start time, future end time and COMMON copy type """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, 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) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9744_tc_er_018_private_copy(stream, name, copy_type): """ Private copy - Archive/Pre-gen """ web_service_obj = None recording = None stream = str(private_copy_stream) try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, 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) assert is_valid, error # wait for georbage collect archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error 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)
def test_rtc9773_tc_arc_003_common(stream): """ Create a recording with copy type as COMMON and check whether archival is happening or not """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) 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) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).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_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9775_tc_arc_005_playback_archive_in_progress(stream): """ Create a recording with copy type as UNIQUE and play it back when archival is in progress """ recording = None web_service_obj = None try: 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(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) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, [Cos.RECORDING_STORED, Cos.RECORDING_PARTIALLY_STORED]) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle(recording_id) assert is_valid, error # If we playback recording when archival is INPROGRESS, There is a chance of few segments being played from # Active storage. This means that only part of the segments would move from archive to recon. # The rest will move from active to archive. So both PARTIALLY_STORED and STORED are valid is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.RECON_STORAGE, [Cos.RECORDING_STORED, Cos.RECORDING_PARTIALLY_STORED]) assert is_valid, ValidationError.SEGMENT_NOT_MOVED.format(Cos.RECON_STORAGE, 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_rtc9756_tc_rec_010_recording_stop_after_recording_start(stream): """ Create a recording and once it starts, stop it by setting the end time as the current time """ recording = None web_service_obj = None try: 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(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 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(constants.SECONDS * 60) recording.get_entry(0).EndTime = utils.get_formatted_time(constants.SECONDS * 0, TimeFormat.TIME_FORMAT_MS, stream) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error time.sleep(constants.SECONDS * 4) is_valid, error = validate_recordings.validate_recording_end_state(recording_id, [RecordingStatus.COMPLETE], web_service_obj=web_service_obj) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_sanity_hybrid_copy(stream, name, copy_type): """ Schedule UNIQUE and COMMON copy on same channel and verify the recording and playback. """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) 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) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_sanity_rtc10065_private_copy(stream): """ Schedule Private copy and verify the recording and playback. """ recording = None web_service_obj = None stream = str(private_copy_stream) try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, 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) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error 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)
def test_tc_rec_038_013_active_asset(stream, name, total_recording): """ Bulk deletion of assets in Active(20 requests) """ recording = None web_service_objects = [] recording_pool = None recording_id_list = [] try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(total_recordings=total_recording, StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) for i in range(total_recording): recording_id = recording.get_entry(i).RecordingId recording_id_list.append(recording_id) 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()) 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_pool = mp_pool.ThreadPool(processes=total_recording) for i in range(total_recording): recording_pool.apply_async( validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objects[i]), callback=queue.put) for i in range(total_recording): is_valid, error = queue.get() assert is_valid, error for i in range(total_recording): response = rio.find_recording(recording_id_list[i]).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error response = a8.delete_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error for i in range(total_recording): is_valid, error = validate_recordings.validate_recording_deletion( recording_id_list[i]) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle( recording_id_list[i]) assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format( recording_id_list[i]) finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objects: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
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 try: 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) total_recording = same_start_time_recordings last_recording_id = recording.Entries[same_start_time_recordings - 1].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 finally: 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_tc_er_006_007_incomplete_delete_playback_US62461(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 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 * 160, 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 * 160) + 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)) 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() last_recording_id = rec_with_diff_time.Entries[0].RecordingId 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 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 #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 recording.Entries.pop(-1) # Deleting all but one recording response = a8.delete_recording(recording) #wait for georbage collect archive_helper.wait_for_archival(stream, recording.get_entry(-1).RecordingId, Archive.ARCHIVE, Archive.COMPLETE) #Verifying playback of recording is_valid, error = validate_recordings.validate_playback_using_vle(rec_with_diff_time.Entries[0].RecordingId,) 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(rec_with_diff_time) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9782_tc_arc_012_playback_after_archival_delete_during_playback( stream): """ Create a recording with unique copy, wait until archiving completes, playback the recording and delete the recording during playback """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, 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 is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error vmr_plybk_url = utils.get_vmr_playback_url(recording_id=recording_id) print "[INFO: ] vmr playback url ", vmr_plybk_url archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() print "[INFO: ] recording details ", response is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error queue = Queue.Queue() playback_pool = mp_pool.ThreadPool(processes=1) playback_pool.apply_async( validate_recordings.validate_playback_using_vle, (recording_id, ), callback=queue.put) #time.sleep(10 * constants.SECONDS) is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, ValidationError.SEGMENT_NOT_MOVED.format( Cos.RECON_STORAGE, response) del_resp = a8.delete_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( del_resp, 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 = queue.get() assert is_valid, error if is_valid: # verifying whether the recording available in VMR vmr_plybk_url = utils.get_vmr_playback_url( recording_id=recording_id) resp = requests.get(vmr_plybk_url) assert not ( resp.status_code == requests.codes.ok ), ValidationError.INCORRECT_HTTP_RESPONSE_STATUS_CODE.format( resp.status_code, resp.reason, resp.url) finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9726_tc_er_018_private_copy(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 try: #Taking backup of v2pc pod config info, editing the config and then restarting the services is_valid, error = cleanup(redeploy_config_map, V2pc.MANIFEST_AGENT, 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(V2pc.MANIFEST_AGENT, Component.VMR, "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 * 80, 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 * 80)+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 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 #Verifying recording is completed 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.COMPLETE, wait_time), 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_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 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 finally: #Revert back the v2pc config changes is_valid, error = cleanup(redeploy_config_map, V2pc.MANIFEST_AGENT, 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_tc_arc_(name, stream, event): """ test_tc_arc_[009_multiple_playback_one_unique-ARCHIVE --> Create multiple recordings with copy type as UNIQUE, wait for them to get archived, playback one of the them and verify if the recording is present both in the ARCHIVE_STORAGE AND RECON_STORAGE test_tc_arc_[011_multiple_playback_one_re_archive_unique-RE_ARCHIVE --> Create multiple recordings with copy type as UNIQUE, wait for them to get archived, playback one, and wait till it gets re-archived """ LOGGER.info("#####################################################################") LOGGER.info("Starting test_tc_arc_%s", name) total_recordings = 3 recording = None web_service_objs = [] recording_pool = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append(notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].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 recording_pool = mp_pool.ThreadPool(processes=total_recordings) for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objs[i]), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) for i in range(total_recordings): 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_NOT_STORED, i) assert is_valid, error 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 is_valid, error = validate_recordings.validate_playback_using_vle(recording_id) assert is_valid, error response = rio.find_recording(recording.get_entry(0).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_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, error if event == Archive.RE_ARCHIVE: archive_helper.wait_for_archival(stream, recording_id, Archive.RE_ARCHIVE, Archive.COMPLETE) is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_NOT_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_playback, (recording.get_entry(i).RecordingId,), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objs: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_rec(name, stream, copy_type): """ Updating end time of shorter unique copy recording after shorter recording completed, and longer recording in progress. """ total_recordings = 2 validate_rec_wait_time = 240 recording = None web_service_objs = [] recording_pool = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording( total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append( notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].get_url() LOGGER.debug("Recording=%s, UpdateURL=%s", recording_id, web_service_objs[i].get_url()) recording.get_entry(1).EndTime = utils.get_formatted_time( constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) 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 # Validating longer recording parallel recording_id_1 = recording.get_entry(1).RecordingId # recording_pool = mp_pool.ThreadPool(processes=2) recording_pool = mp_pool.ThreadPool() recording_pool.apply_async(validate_recordings.validate_recording, (recording_id_1, web_service_objs[1]), callback=queue.put) # Validating shorter recording to complete recording_id_0 = recording.get_entry(0).RecordingId is_valid, error = validate_recordings.validate_recording( recording_id_0, web_service_objs[0]) assert is_valid, error shorter_recording_res = rio.find_recording(recording_id_0).json() # Validate the copy count for unique/common copy if RecordingAttribute.COPY_TYPE_UNIQUE == copy_type: is_valid, error = validate_storage.validate_copy_count( shorter_recording_res, Cos.ACTIVE_STORAGE, 2) elif RecordingAttribute.COPY_TYPE_COMMON == copy_type: is_valid, error = validate_storage.validate_copy_count( shorter_recording_res, Cos.ACTIVE_STORAGE, 1) assert is_valid, error LOGGER.debug(copy_type + " copy validation success") # Try to update the end time after shorter recording completes response = rio.find_recording(recording_id_0).json() print "[INFO: ] response json ", response updated_end_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).EndTime = updated_end_time shorter_recording_res = a8.create_recording(recording, recording_id_0) response = rio.find_recording(recording_id_0).json() print "[INFO: ] response json ", response is_valid, error = validate_common.validate_http_response_status_code( shorter_recording_res, requests.codes.bad_request) print "[INFO: ] update end time after recording complete message ", error # assert is_valid, "CSCvc21524: - "+error # Validating the updated end time in response, it should not be equal response = rio.find_recording(recording_id_0).json() is_valid, error = validate_recordings.validate_time( response, updated_end_time, RecordingAttribute.END_TIME) assert not is_valid, error print "[INFO: ] Validating the updated end time in response, it should not be equal " print "[INFO: ] async validate recording wait time ", time.sleep( validate_rec_wait_time) print "[INFO: ] queue list empty ", queue.empty() # Validating the longer recording is_valid, error = queue.get(timeout=7) print "[INFO: ] queue value 1 ", is_valid assert is_valid, error print "[INFO: ] Validating the longer recording " # Playback all recordings for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_playback, (recording.get_entry(i).RecordingId, ), callback=queue.put) print "[INFO: ] Playback all recordings " # Validate playback recordings for i in range(total_recordings): is_valid, error = queue.get() print "[INFO: ] queue value 2 ", is_valid assert is_valid, error print "[INFO: ] Validate playback recordings" finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objs: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9769_tc_rec_037_(total_recording, stream, name, copy_type): """ Update the end time of a recording after it starts """ recording = None web_service_objects = [] recording_pool = None recording_id_list = [] try: 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 * 70, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(total_recordings=total_recording, StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) for i in range(total_recording): recording_id = recording.get_entry(i).RecordingId recording_id_list.append(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()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error # wait till the STARTED notification 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() if current_time < start_time: utils.wait(start_time - current_time, constants.TIME_DELTA) for i in range(total_recording): is_valid, error = validate_recordings.validate_notification( web_service_objects[i], constants.RecordingStatus.STARTED) assert is_valid, error # Updating the end time for i in range(total_recording): response = rio.find_recording(recording_id_list[i]).json() LOGGER.debug("Response=%s", response) end_time = response[0][RecordingAttribute.END_TIME][:-1] LOGGER.debug("Scheduled end time of recording=%s is %s", recording_id, end_time) recording.get_entry(i).EndTime = utils.get_formatted_time( constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) new_end_time = recording.get_entry(i).EndTime[:-1] LOGGER.debug("Updated end time of recording=%s to %s", recording_id, recording.get_entry(i).EndTime) 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_pool = mp_pool.ThreadPool(processes=total_recording) end_time = utils.get_parsed_time(new_end_time) 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 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 if copy_type == RecordingAttribute.COPY_TYPE_COMMON: is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error if copy_type == RecordingAttribute.COPY_TYPE_UNIQUE: 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 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 for i in range(total_recording): response = rio.find_recording(recording_id_list[i]).json() is_valid, error = validate_recordings.validate_actual_time( response, recording.get_entry(i).EndTime, RecordingAttribute.ACTUAL_END_TIME) assert is_valid, error finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objects: web_service_obj.stop_server() 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_rtc9788_bulk_update_end_time_during_recording_inprogress_unique( total_recording, stream, name, copy_type): """ TC9788 : Bulk update of recording requests of end time during recording(20 requests ) unique copy """ recording = None web_service_objects = [] recording_pool = None recording_id_list = [] try: 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 * 180, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(total_recordings=total_recording, StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) for i in range(total_recording): recording_id = recording.get_entry(i).RecordingId recording_id_list.append(recording_id) 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()) 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_pool = mp_pool.ThreadPool(processes=total_recording) start_wait = constants.RECORDING_DELAY + 30 sleep_time = utils.get_sleep_time(start_wait, stream) print "[INFO: ] Waiting %d seconds for recording to start" % sleep_time LOGGER.debug("Waiting %d seconds for recording to start", sleep_time) time.sleep(sleep_time) for i in range(total_recording): response = rio.find_recording(recording_id_list[i]).json() LOGGER.debug("Response=%s", response) end_time = response[0][RecordingAttribute.END_TIME][:-1] LOGGER.debug("Scheduled end time of recording=%s is %s", recording_id_list[i], end_time) recording.get_entry(i).EndTime = utils.get_formatted_time( constants.SECONDS * 70, TimeFormat.TIME_FORMAT_MS, stream) LOGGER.debug("Updated end time of recording=%s to %s", recording_id_list[i], recording.get_entry(i).EndTime) # Update the recording with the updated end time response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error # Validating whether the updated end time was populated or not for i in range(total_recording): response = rio.find_recording(recording_id_list[i]).json() LOGGER.debug("Response=%s", response) is_valid, error = validate_recordings.validate_time( response, recording.get_entry(i).EndTime, RecordingAttribute.END_TIME) assert is_valid, error for i in range(total_recording): recording_pool.apply_async( validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objects[i]), callback=queue.put) for i in range(total_recording): is_valid, error = queue.get() assert is_valid, error finally: if recording_pool: recording_pool.close() recording_pool.join() if len(web_service_objects): 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_rtc9799_tc_ply_008_playback_pause_resume(stream): """ Create a recording, pause and resume during playback and verify if playback was successful """ recording = None web_service_obj = None pause_trigger = 2 pause_duration = 5 try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, 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) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error vle_request_params = { Vle.TRICKMODES: '{0},{1},{2},{3}'.format(Vle.TRICKMODE_PAUSE, pause_trigger, pause_duration, Vle.PAUSE_WRT_SEGMENT) } is_valid, error = validate_recordings.validate_playback( recording_id, VLE_REQUEST_PARAMS=vle_request_params, VALIDATOR_TYPE=vle_validators_configuration. PLAYBACK_VALIDATION_TRICKMODE) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_update_recording_ipdvrtests_48(common_lib, stream): """ JIRA_URL : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-48 DESCRIPTION : "Update Recording" """ recording = None web_service_obj = None try: #step 1:Create a recording and update the end time. Alternatively update start time if original start time is in future ##creating a recording recording, web_service_obj = common_lib.create_recording(stream) ##change the start time of the recording start_time_new = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).StartTime = start_time_new ##change the end time of the recording end_time_new = utils.get_formatted_time(constants.SECONDS * 110, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).EndTime = end_time_new response = a8.create_recording(recording) recording_id = recording.get_entry(0).RecordingId is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error ##verify the recording complete is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error #step 2:Verify memsql table is updated with new time using RIO API response = rio.find_recording(recording_id) resp = json.loads(response.content) is_valid, error = validate_recordings.validate_time( resp, start_time_new, RecordingAttribute.START_TIME) assert is_valid, error is_valid, error = validate_recordings.validate_time( resp, end_time_new, RecordingAttribute.END_TIME) assert is_valid, error #step 3:Check cos logs to see segments are written using COS API 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 s_time = utils.get_parsed_time(str(start_time_new)[:-1]) e_time = utils.get_parsed_time(str(end_time_new)[:-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 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 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)
def test_rtc9813_tc_des_006_dcm_multi_cast_ip_packet_loss_recording(): """ Introduce 30% packet loss on the Incoming MCE network interface throughout the recording life time, Validate recording state against INCOMPLETE or COMPLETE and number of available segments recorded. """ ssh_client = None response = None web_service_obj = None try: rev_cmds = {} mce_nodes = v2pc.get_app_worker_nodes(MCE_INSTANCE, COMPONENT_NAME) for mce_node in mce_nodes: mce_data_in = mce_node[Interface.DATA_IN] mce_ip = mce_node[Component.IP] ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_ip) # deleting the previously scheduled jobs by other test cases, in order not to tamper with the current test case destructive_utils.delete_scheduled_job(COMPONENT_NAME, ssh_client, mce_ip, destructive.MCE_JOB_IDS) if mce_node[Interface.DATA_IN] != mce_node[Interface.MGMT]: rev_cmds[mce_ip] = destructive_utils.schedule_rev_cmd(ssh_client, mce_data_in, mce_ip, destructive.MCE_JOB_IDS, constants.MINUTES * 10) else: destructive_utils.schedule_rev_cmd(ssh_client, mce_data_in, mce_ip, destructive.MCE_JOB_IDS, constants.MINUTES * 2) rev_cmds[mce_ip] = None des_cmd = DestructiveTesting.PACKET_LOSS_INCOMING_INTERFACE.format(DestructiveTesting.IFB_INTERFACE, DestructiveTesting.PACKET_LOSS) des_cmd = destructive_utils.get_incoming_tc_cmd(mce_data_in, des_cmd) # expected outcome after the destructive commands are run expected_result = {DestructiveTesting.LOSS: DestructiveTesting.PACKET_LOSS, DestructiveTesting.SRC: DestructiveTesting.NETWORK} is_des_effective, error = destructive_utils.exec_des_cmd(ssh_client, DestructiveTesting.IFB_INTERFACE, des_cmd, expected_result) assert is_des_effective, error start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, STREAM_ID) end_time = utils.get_formatted_time(constants.SECONDS * 90, TimeFormat.TIME_FORMAT_MS, STREAM_ID) response = destructive_utils.create_recording_des(start_time, end_time) recording_id = response[RecordingAttribute.RECORDING_ID] recording_response = rio.find_recording(recording_id).json() LOGGER.debug("Recording response=%s", recording_response) web_service_obj = response[RecordingAttribute.WEB_SERVICE_OBJECT] is_valid, desc = validate_recordings.validate_recording_end_state( recording_id, [RecordingStatus.INCOMPLETE, RecordingStatus.COMPLETE], web_service_obj=web_service_obj, end_time=end_time) assert is_valid, desc if is_valid and desc == RecordingStatus.COMPLETE: is_valid, error = validate_recordings.validate_playback_using_vle( recording_id, VALIDATOR_TYPE=vle_validators_configuration.PLAYBACK_VALIDATION_COMPLETE) assert is_valid, error # executing the revert command to undo the destructive commands for mce_node in mce_nodes: ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_node[Component.IP]) if rev_cmds[mce_ip]: rev_effective, error = destructive_utils.exec_rev_cmd(COMPONENT_NAME, ssh_client, mce_ip, DestructiveTesting.IFB_INTERFACE, rev_cmds[mce_ip], destructive.MCE_JOB_IDS) else: rev_effective, error = destructive_utils.is_rev_effective(ssh_client, DestructiveTesting.IFB_INTERFACE) assert rev_effective, error # running sanity test to check if the setup is back to normal after reverting the commands test_rtc9723_tc_rec_001_future_start_time_future_end_time(STREAM_ID) finally: if ssh_client: ssh_client.close() if web_service_obj: web_service_obj.stop_server() if response: response = a8.delete_recording(response[RecordingAttribute.RECORDING]) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_arc(name, stream, archive_playback): """ Schedule recording with same start time, end time with unique copy, playback recording single recording and delete it, finally playback remaining records. """ total_recordings = 3 recording = None web_service_objs = [] recording_pool = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE recording = recording_model.Recording( total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append( notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].get_url() LOGGER.debug("Recording=%s, UpdateURL=%s", recording_id, web_service_objs[i].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_pool = mp_pool.ThreadPool(processes=total_recordings) for i in range(total_recordings): recording_pool.apply_async( validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objs[i]), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error # Validating the copy count of unique copy recording in active storage for i in range(total_recordings): response = rio.find_recording( recording.get_entry(i).RecordingId).json() is_valid, error = validate_storage.validate_copy_count( response, Cos.ACTIVE_STORAGE, total_recordings) assert is_valid, error # Wait till archival completes recording_id_0 = recording.get_entry(0).RecordingId archive_helper.wait_for_archival(stream, recording_id_0, Archive.ARCHIVE, Archive.COMPLETE) # Validating copy count in archive storage after archival duration for i in range(total_recordings): 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_NOT_STORED) assert is_valid, error 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, 1) assert is_valid, error if archive_playback: response = rio.find_recording(recording_id_0).json() # Validating the first recording for playback is_valid, error = validate_recordings.validate_playback_using_vle( recording_id_0) assert is_valid, error # Validating the copy of segments in the archive folder after playback is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error # Validating the segments in recon folder after playback is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, error response = a8.delete_recording(recording, recording.get_entry(0).RecordingId) 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_0) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle( recording_id_0) assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format( recording_id_0) del recording.get_entries()[:1] # Check remaining records still in archive if archive_playback: for recording_entry in recording.get_entries(): response = rio.find_recording( recording_entry.RecordingId).json() recording_pool.apply_async( validate_storage.validate_recording_in_storage, (response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED), callback=queue.put) for i in range(len(recording.get_entries())): is_valid, error = queue.get() assert is_valid, error for recording_entry in recording.get_entries(): recording_pool.apply_async( validate_recordings.validate_playback_using_vle, (recording_entry.RecordingId, ), callback=queue.put) for i in range(len(recording.get_entries())): is_valid, error = queue.get() assert is_valid, error finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objs: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9763_tc_rec_027_multiple_delete_playback_unique(stream): """ Create multiple recordings with copy type as UNIQUE, delete one and playback the rest """ total_recordings = 3 web_service_objs = [] playback_pool = None recording = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording( total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append( notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].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_0 = recording.get_entry(0).RecordingId recording_pool = mp_pool.ThreadPool(processes=total_recordings) for i in range(total_recordings): recording_pool.apply_async( validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objs[i]), callback=queue.put) for i in range(total_recordings): is_valid, error = queue.get() assert is_valid, error for i in range(total_recordings): response = rio.find_recording( recording.get_entry(i).RecordingId).json() is_valid, error = validate_storage.validate_copy_count( response, Cos.ACTIVE_STORAGE, total_recordings) assert is_valid, error recording_to_delete = copy.deepcopy(recording) del recording_to_delete.get_entries()[1:] del recording.get_entries()[:1] # to clean up recordings later response = a8.delete_recording(recording_to_delete) 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_0) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle( recording_id_0) assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format( recording_id_0) playback_pool = mp_pool.ThreadPool( processes=len(recording.get_entries())) for recording_entry in recording.get_entries(): playback_pool.apply_async( validate_recordings.validate_playback_using_vle, (recording_entry.RecordingId, ), callback=queue.put) for i in range(len(recording.get_entries())): is_valid, error = queue.get() assert is_valid, error finally: if playback_pool: playback_pool.close() playback_pool.join() for web_service_obj in web_service_objs: 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_rtc9801_tc_des_008_mce_ni_block_pending_recording(): """ Block traffic on the outgoing MCE interface, trigger a recording(4 minutes) and unblock the interface after 2 minutes Check if the recording is INCOMPLETE. Verify the playback of recording """ ssh_client = None response = None start_duration = 30 end_duration = 270 try: rev_cmds = {} mce_nodes = v2pc.get_app_worker_nodes(MCE_INSTANCE, COMPONENT_NAME) for mce_node in mce_nodes: mce_data_out = mce_node[Interface.DATA_OUT] mce_ip = mce_node[Component.IP] ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_ip) # deleting the previously scheduled jobs by other test cases, in order not to tamper with the current test case destructive_utils.delete_scheduled_job(COMPONENT_NAME, ssh_client, mce_ip, destructive.MCE_JOB_IDS) des_cmd = DestructiveTesting.PACKET_LOSS_OUTGOING_INTERFACE.format( mce_data_out, DestructiveTesting.PACKET_LOSS_BLOCK) des_cmd = destructive_utils.get_outgoing_tc_cmd( mce_data_out, des_cmd) if mce_node[Interface.DATA_OUT] != mce_node[Interface.MGMT]: rev_cmds[mce_ip] = destructive_utils.schedule_rev_cmd( ssh_client, mce_data_out, mce_ip, destructive.MCE_JOB_IDS, constants.MINUTES * 10) expected_result = { DestructiveTesting.LOSS: DestructiveTesting.PACKET_LOSS_BLOCK, DestructiveTesting.DST: DestructiveTesting.NETWORK } is_des_effective, error = destructive_utils.exec_des_cmd( ssh_client, mce_data_out, des_cmd, expected_result) assert is_des_effective, error else: destructive_utils.schedule_rev_cmd(ssh_client, mce_data_out, mce_ip, destructive.MCE_JOB_IDS, constants.MINUTES * 2) rev_cmds[mce_ip] = None LOGGER.info( "Executing the command=%s to cause destruction in the component", des_cmd) ssh_client.exec_command(des_cmd) start_time = utils.get_formatted_time( constants.SECONDS * start_duration, TimeFormat.TIME_FORMAT_MS, STREAM_ID) end_time = utils.get_formatted_time(constants.SECONDS * end_duration, TimeFormat.TIME_FORMAT_MS, STREAM_ID) response = destructive_utils.create_recording_des(start_time, end_time) time.sleep(end_duration + constants.TIME_DELTA) for mce_node in mce_nodes: mce_ip = mce_node[Component.IP] mce_data_out = mce_node[Interface.DATA_OUT] ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_ip) if rev_cmds[mce_ip]: rev_effective, error = destructive_utils.exec_rev_cmd( COMPONENT_NAME, ssh_client, mce_ip, rev_cmds[mce_ip], mce_data_out, destructive.MCE_JOB_IDS) else: rev_effective, error = destructive_utils.is_rev_effective( ssh_client, mce_data_out) assert rev_effective, error is_valid, rec_error = validate_recordings.validate_recording_end_state( response[RecordingAttribute.RECORDING_ID], [RecordingStatus.INCOMPLETE], web_service_obj=response[RecordingAttribute.WEB_SERVICE_OBJECT]) recording_response = rio.find_recording( response[RecordingAttribute.RECORDING_ID]).json() LOGGER.debug("Recording response=%s", recording_response) assert is_valid, rec_error # validate playback to check if available segments are recorded is_valid, error = validate_recordings.validate_playback( response[RecordingAttribute.RECORDING_ID]) assert is_valid, error # running sanity test to check if the setup is back to normal after reverting the commands test_rtc9723_tc_rec_001_future_start_time_future_end_time(STREAM_ID) finally: if ssh_client: ssh_client.close() if response: response[RecordingAttribute.WEB_SERVICE_OBJECT].stop_server() response = a8.delete_recording( response[RecordingAttribute.RECORDING]) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_rec_033_015_(total_recording, stream, name, copy_type): """ Create multiple recordings with copy type as COMMON """ web_service_objects = [] recording_pool = None recording = None try: 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 * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(total_recordings=total_recording, StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) 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()) 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_pool = mp_pool.ThreadPool(processes=total_recording) for i in range(total_recording): recording_pool.apply_async( validate_recordings.validate_recording, (recording.get_entry(i).RecordingId, web_service_objects[i]), callback=queue.put) for i in range(total_recording): is_valid, error = queue.get() assert is_valid, error 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 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 if copy_type == RecordingAttribute.COPY_TYPE_COMMON: is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error if copy_type == RecordingAttribute.COPY_TYPE_UNIQUE: 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 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: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objects: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9735_er_011_hybrid_recording_recovery_manifest_restart(stream): """ Hybrid (UNIQUE and COMMON) copy Recording recovery """ web_service_objects = [] recording_pool = None recording = None total_recording = 10 common_copy_recordings = 5 unique_copy_recordings = 5 try: 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 * 120, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording( total_recordings=common_copy_recordings, StartTime=start_time, EndTime=end_time, copyType=RecordingAttribute.COPY_TYPE_COMMON, StreamId=stream) for i in range(unique_copy_recordings, total_recording): rec_uniq = recording_model.Recording( total_recordings=unique_copy_recordings, StartTime=start_time, EndTime=end_time, copyType=RecordingAttribute.COPY_TYPE_UNIQUE, StreamId=stream) rec_uniq.Entries[ 0].RecordingId = RecordingAttribute.RECORDING_ID_PREFIX + rec_uniq.RequestId + '_' + str( i) recording.Entries.append(rec_uniq.get_entry(0)) last_recording_id = rec_uniq.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 # Restarting manifest agent is_valid, error = delete_vmr_pods(V2pc.MANIFEST_AGENT) assert is_valid, error 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: 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)