def test_long_to_short_retry_switch_on_authentication(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Test the number of expected retries and the gap between 2 retries on authentication requests occurring in the background thread """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() expires_in = 1 retryShortPeriod = 3 retryLongPeriod = 10 timeoutSecond = 25 conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json['settings']['ws_retry_period_short'] = retryShortPeriod conf_json['settings']['ws_retry_period_long'] = retryLongPeriod conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: context = { 'data': list(), 'cnt': 0, 'expires_in': expires_in, 'timeoutSecond': timeoutSecond, 'exit': False } set_context(context) assert get_context() == context drm_manager.activate() wait_func_true(lambda: async_cb.was_called, timeout=timeoutSecond * 2) context = get_context() context['exit'] = True set_context(context) assert get_context() == context drm_manager.deactivate() assert async_cb.was_called assert async_cb.errcode == accelize_drm.exceptions.DRMWSTimedOut.error_code assert search(r'Timeout on Authentication request after', async_cb.message, IGNORECASE) context = get_context() data_list = context['data'] data = data_list.pop(0) data = data_list.pop(-1) assert len(data_list) >= 3 data = data_list.pop(0) prev_lic = parser.parse(data[1]) for start, end in data_list: lic_delta = int((parser.parse(start) - prev_lic).total_seconds()) prev_lic = parser.parse(end) if lic_delta > retryShortPeriod: assert (retryLongPeriod - 1) <= lic_delta <= retryLongPeriod else: assert (retryShortPeriod - 1) <= lic_delta <= retryShortPeriod
def test_health_retry_modification(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test the asynchronous health retry can be modified dynamically. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() healthPeriod = 3 healthRetry = 10 healthRetrySleep = 1 nb_run = 3 for i in range(nb_run): retry_timeout = healthRetry + 5 * i # Set initial context on the live server context = { 'data': list(), 'healthPeriod': healthPeriod, 'healthRetry': retry_timeout, 'healthRetrySleep': healthRetrySleep, 'exit': False } set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() wait_func_true(lambda: get_context()['exit'], timeout=(retry_timeout + 3) * 2) drm_manager.deactivate() error_gap = drm_manager.get('health_retry_sleep') + 1 async_cb.assert_NoError() data_list = get_context()['data'] data0 = data_list.pop(0) assert len(data_list) > 1 assert data0[0] == 0 # Check health_id is unchanged during the retry period assert sum(map(lambda x: x[0], data_list)) == len(data_list) # Check the retry period is correct start = data_list[0][1] end = data_list[-1][2] delta = parser.parse(end) - parser.parse(start) assert retry_timeout - error_gap <= int( delta.total_seconds()) <= retry_timeout + error_gap assert get_proxy_error() is None
def test_health_retry_sleep_modification(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test the asynchronous health retry sleep value when changed dynamically. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() healthPeriod = 3 healthRetry = 10 healthRetrySleep = 1 nb_run = 3 for i in range(nb_run): health_retry_sleep = healthRetrySleep + i # Set initial context on the live server context = { 'data': list(), 'healthPeriod': healthPeriod, 'healthRetry': healthRetry, 'healthRetrySleep': health_retry_sleep, 'exit': False } set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() wait_func_true(lambda: get_context()['exit'], timeout=(healthRetry + healthRetry) * 2) drm_manager.deactivate() async_cb.assert_NoError() data_list = get_context()['data'] data0 = data_list.pop(0) nb_sleep_prev = 0 # Check the retry sleep period is correct for health_id, group in groupby(data_list, lambda x: x[0]): group = list(group) assert len(group) > nb_sleep_prev nb_sleep_prev = len(group) start = group.pop(0)[2] for _, lstart, lend in group: delta = parser.parse(lstart) - parser.parse(start) assert int(delta.total_seconds()) == health_retry_sleep start = lend assert get_proxy_error() is None
def test_api_retry_on_lost_connection(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the number of expected retries and the gap between 2 retries are correct when the requests are lost on the activate call """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: retry_duration = drm_manager.get('ws_api_retry_duration') retry_timeout = drm_manager.get('ws_request_timeout') retry_sleep = drm_manager.get('ws_retry_period_short') nb_attempts_expected = int(retry_duration / (retry_timeout + retry_sleep)) + 1 assert nb_attempts_expected >= 1 context = {'data': list(), 'sleep': retry_timeout + 1} set_context(context) assert get_context() == context with pytest.raises(accelize_drm.exceptions.DRMWSTimedOut) as excinfo: drm_manager.activate() assert async_handler.get_error_code(str( excinfo.value)) == accelize_drm.exceptions.DRMWSTimedOut.error_code m = search(r'Timeout on License request after (\d+) attempts', str(excinfo.value)) assert m is not None nb_attempts = int(m.group(1)) assert nb_attempts_expected == nb_attempts log_content = logfile.read() attempts_list = [ int(e) for e in findall( r'Attempt #(\d+) to obtain a new License failed with message', log_content) ] assert len(attempts_list) == nb_attempts_expected assert sorted(list(attempts_list)) == list(range(1, nb_attempts + 1)) # Check time between each call data = get_context()['data'] assert len(data) == nb_attempts_expected prev_time = parser.parse(data.pop(0)) for time in data: delta = int((parser.parse(time) - prev_time).total_seconds()) assert retry_timeout + retry_sleep - 1 <= delta <= retry_timeout + retry_sleep prev_time = parser.parse(time) async_cb.assert_Error(accelize_drm.exceptions.DRMWSTimedOut.error_code, HTTP_TIMEOUT_ERR_MSG) async_cb.reset() logfile.remove()
def wait_and_check_on_next_health(drm): next_health_id = get_context()['health_id'] + 1 wait_func_true( lambda: get_context()['health_id'] >= next_health_id) session_id = drm.get('session_id') saas_data = ws_admin.get_last_metering_information(session_id) assert saas_data['session'] == session_id assert saas_data['metering'] == sum(drm.get('metered_data'))
def test_long_to_short_retry_switch_on_license(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Test the number of expected retries and the gap between 2 retries on license requests occurring in the background thread """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() retryShortPeriod = 3 retryLongPeriod = 10 timeoutSecond = 25 conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json['settings']['ws_retry_period_short'] = retryShortPeriod conf_json['settings']['ws_retry_period_long'] = retryLongPeriod conf_json.save() context = {'data': list(), 'cnt': 0, 'timeoutSecond': timeoutSecond} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() lic_duration = drm_manager.get('license_duration') wait_func_true(lambda: async_cb.was_called, timeout=lic_duration + 2 * timeoutSecond) drm_manager.deactivate() assert async_cb.was_called assert 'Timeout on License' in async_cb.message assert async_cb.errcode == accelize_drm.exceptions.DRMWSTimedOut.error_code context = get_context() data_list = context['data'] data = data_list.pop(0) data = data_list.pop(-1) assert len(data_list) >= 3 data = data_list.pop(0) assert data[0] == 'running' prev_lic = parser.parse(data[2]) for type, start, end in data_list: assert type == 'running' lic_delta = int((parser.parse(start) - prev_lic).total_seconds()) prev_lic = parser.parse(end) if lic_delta > retryShortPeriod: assert (retryLongPeriod - 1) <= lic_delta <= retryLongPeriod else: assert (retryShortPeriod - 1) <= lic_delta <= retryShortPeriod
def test_health_period_disabled(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the asynchronous health feature can be disabled. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server nb_health = 2 healthPeriod = 2 context = { 'cnt': 0, 'healthPeriod': healthPeriod, 'nb_health': nb_health, 'exit': False } set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() assert drm_manager.get('health_period') == healthPeriod wait_func_true(lambda: get_context()['exit'], timeout=healthPeriod * (nb_health + 1) * 2) assert drm_manager.get('health_period') == 0 assert get_context()['cnt'] == nb_health sleep(healthPeriod + 1) assert get_context()['cnt'] == nb_health drm_manager.deactivate() log_content = logfile.read() assert search(r'Exiting background thread which checks health', log_content, MULTILINE) assert search(r'Health thread is disabled', log_content, MULTILINE) assert search(r'Exiting background thread which checks health', log_content, MULTILINE) health_req = findall(r'"request"\s*:\s*"health"', log_content) assert len(list(health_req)) == nb_health assert get_proxy_error() is None async_cb.assert_NoError() logfile.remove()
def test_async_call_on_pause_when_health_is_enabled(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the DRM pause function does perform a async request before pausing """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing'][ 'url'] = _request.url + 'test_async_call_on_pause_depending_on_health_status' logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server context = {'healthPeriod': 300, 'healthRetry': 0, 'health_cnt': 0} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # First, get license duration to align health period on it drm_manager.activate() drm_manager.deactivate(True) # Pause session drm_manager.deactivate() async_cb.assert_NoError() # Check the proxy received only 1 health request (corresponding to the pause call) context = get_context() assert context['health_cnt'] == 1 # Check the health request occurred after the pause call pause_line = 0 health_line = 0 stop_line = 0 for i, line in enumerate(logfile.read().split('\n')): if search(r"'pause_session_request'\s*=\s*true", line, IGNORECASE): pause_line = i elif search(r'"request"\s*:\s*"health"', line, IGNORECASE): health_line = i elif search(r"'pause_session_request'\s*=\s*false", line, IGNORECASE): stop_line = i assert pause_line > 0 and health_line > 0 and stop_line > 0 assert pause_line < health_line < stop_line assert get_proxy_error() is None logfile.remove()
def test_health_retry_disabled(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test the asynchronous health retry feature can be disabled. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # Set initial context on the live server nb_health = 2 healthPeriod = 3 healthRetrySleep = 1 context = { 'data': list(), 'healthPeriod': healthPeriod, 'healthRetrySleep': healthRetrySleep } set_context(context) assert get_context() == context drm_manager.activate() wait_func_true(lambda: len(get_context()['data']) >= nb_health, timeout=(healthPeriod + 3) * (nb_health + 2)) drm_manager.deactivate() async_cb.assert_NoError() data_list = get_context()['data'] assert len(data_list) >= nb_health # Check there is no duplicated health_id id_list = tuple(map(lambda x: x[0], data_list)) assert id_list == tuple(set(id_list)) # Check the time between 2 period wait_start = data_list.pop(0)[2] for hid, start, end in data_list: delta = parser.parse(start) - parser.parse(wait_start) assert int(delta.total_seconds()) == healthPeriod wait_start = end assert get_proxy_error() is None
def test_authentication_token_renewal(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """Test a different authentication token is given after expiration""" driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() cred_json.set_user('accelize_accelerator_test_02') conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json.save() # Set initial context on the live server expires_in = 6 context = {'expires_in': expires_in} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() start = datetime.now() lic_duration = drm_manager.get('license_duration') token_string = drm_manager.get('token_string') token_time_left = drm_manager.get('token_time_left') sleep(token_time_left) # Wait expiration of token # Compute expiration of license for the token to be renewed q = int(expires_in / lic_duration) next_lic_expiration = ((q + 1) * lic_duration) % expires_in sleep(next_lic_expiration + 5) # Wait current license expiration assert drm_manager.get('token_string') != token_string
def test_improve_coverage_ws_client(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Improve coverage of the httpCode2DrmCode function """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json.save() # Set initial context on the live server error_code = 600 context = {'error_code': error_code} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: with pytest.raises(accelize_drm.exceptions.DRMWSError) as excinfo: drm_manager.activate() assert async_handler.get_error_code(str( excinfo.value)) == accelize_drm.exceptions.DRMWSError.error_code assert get_proxy_error() is None async_cb.assert_Error(accelize_drm.exceptions.DRMWSError.error_code, 'Metering Web Service error 600') async_cb.reset()
def test_health_period_modification(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test the asynchronous health feature can be modified dynamically. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server nb_health = 4 healthPeriod = 2 healthRetry = 0 # no retry healthRetrySleep = 1 context = { 'data': list(), 'healthPeriod': healthPeriod, 'healthRetry': healthRetry, 'healthRetrySleep': healthRetrySleep } set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() wait_func_true(lambda: len(get_context()['data']) >= nb_health, timeout=(healthPeriod + 3) * (nb_health + 2)) drm_manager.deactivate() async_cb.assert_NoError() data_list = get_context()['data'] assert len(data_list) >= nb_health wait_start = data_list.pop(0)[1] for i, (start, end) in enumerate(data_list): delta = parser.parse(start) - parser.parse(wait_start) assert int(delta.total_seconds()) == healthPeriod + i wait_start = end assert get_proxy_error() is None
def test_session_id_error(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test an error is returned if a wrong session id is provided """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() activators = accelize_drm.pytest_fpga_activators[0] activators.reset_coin() activators.autotest() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server context = {'session_id': '0', 'session_cnt': 0, 'request_cnt': 0} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # Start session #1 to record drm_manager.activate() start = datetime.now() assert drm_manager.get('license_status') activators.autotest(is_activated=True) lic_duration = drm_manager.get('license_duration') wait_period = start + timedelta(seconds=lic_duration + 2) - datetime.now() sleep(wait_period.total_seconds()) assert drm_manager.get('license_status') drm_manager.deactivate() assert not drm_manager.get('license_status') activators.autotest(is_activated=False) async_cb.assert_NoError() # Start session #2 to replay session #1 drm_manager.activate() start = datetime.now() assert drm_manager.get('license_status') activators.autotest(is_activated=True) lic_duration = drm_manager.get('license_duration') wait_period = start + timedelta(seconds=lic_duration + 2) - datetime.now() sleep(wait_period.total_seconds()) assert not drm_manager.get('license_status') activators.autotest(is_activated=False) drm_manager.deactivate() assert async_cb.was_called assert async_cb.errcode == accelize_drm.exceptions.DRMCtlrError.error_code assert search(r"License (header|MAC) check error", async_cb.message)
def test_no_async_call_on_pause_when_health_is_disabled( accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the DRM pause function does NOT perform a async request before pausing """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing'][ 'url'] = _request.url + 'test_async_call_on_pause_depending_on_health_status' logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server context = {'healthPeriod': 0, 'healthRetry': 0, 'health_cnt': 0} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # First, get license duration to align health period on it drm_manager.activate() lic_dur = drm_manager.get('license_duration') drm_manager.deactivate(True) # Pause session drm_manager.deactivate() async_cb.assert_NoError() # Check the proxy did not receive any health request context = get_context() assert context['health_cnt'] == 0 # Check no health request appeared in the log file assert search(r'"request"\s*:\s*"health"', logfile.read(), IGNORECASE) is None assert get_proxy_error() is None logfile.remove()
def test_normal_usage(accelize_drm, request, exec_func, live_server, tmpdir, log_file_factory): """Check memory leak with valgrind""" if 'aws' not in accelize_drm.pytest_fpga_driver_name: pytest.skip("C unit-tests are only supported with AWS driver.") if accelize_drm.is_ctrl_sw: pytest.skip("Test skipped on SoM target: valgrind is not installed") # Set initial context on the live server nb_running = 2 healthPeriod = 2 context = {'healthPeriod': healthPeriod} set_context(context) assert get_context() == context # Create C/C++ executable exec_func._conf_json['licensing'][ 'url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(0) exec_func._conf_json['settings']['ws_connection_timeout'] = 15 exec_func._conf_json['settings']['ws_request_timeout'] = 30 exec_func._conf_json['settings']['ws_api_retry_duration'] = 60 exec_func._conf_json['settings'].update(logfile.json) exec_func._conf_json.save() driver = accelize_drm.pytest_fpga_driver[0] valgrind_log_file = join(accelize_drm.pytest_artifacts_dir, 'valgrind.log') exec_lib = exec_func.load('unittests', driver._fpga_slot_id, valgrind_log_file) # Run executable param_file = tmpdir.join('params.json') param_file.write('{"nb_running":%d}' % nb_running) # Save exec parameters to file exec_lib.run(request.function.__name__, param_file) assert exec_lib.returncode == 0 content = logfile.read() assert search(r'DRM session \S{16} created', content, IGNORECASE) assert search(r'DRM session \S{16} stopped', content, IGNORECASE) assert search(r'\[\s*(error|critical)\s*\]', content, IGNORECASE) is None assert search(r'\[\s*trace\s*\]', content, IGNORECASE) # Analyze valgrind output file assert isfile(valgrind_log_file) with open(valgrind_log_file, 'rt') as f: content = f.read() assert search(r'definitely lost: 0 bytes in 0 blocks', content, IGNORECASE) assert search(r'indirectly lost: 0 bytes in 0 blocks', content, IGNORECASE) assert search(r'possibly lost: 0 bytes in 0 blocks', content, IGNORECASE) assert search(r'ERROR SUMMARY: 0 errors from 0 contexts', content, IGNORECASE) logfile.remove()
def test_topic0_corrupted_segment_index(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Test to reproduce the issue that corrupts the segment ID with both async and syn requests. !!! CAUTION: THIS TEST ENDS CORRECTLY ONLY WHEN AN ERROR IS HIT !!! !!! IT SHOULD NOT BE PART OF A NORMAL REGRESSION !!! """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json.save() with accelize_drm.DrmManager( conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback ) as drm_manager: # Set initial context on the live server healthPeriod = 10 context = {'error':0, 'healthPeriod':healthPeriod } set_context(context) assert get_context() == context drm_manager.activate() wait_func_true(lambda: get_context()['error'], timeout=60) drm_manager.deactivate() async_cb.assert_NoError()
def test_header_error_on_licenseTimer(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test a MAC error is returned if the licenseTimer value in the response has been modified """ driver = accelize_drm.pytest_fpga_driver[0] # Program FPGA with lastest HDK per major number image_id = driver.fpga_image driver.program_fpga(image_id) async_cb = async_handler.create() async_cb.reset() activators = accelize_drm.pytest_fpga_activators[0] activators.reset_coin() activators.autotest() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server context = {'cnt': 0} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() start = datetime.now() lic_duration = drm_manager.get('license_duration') assert drm_manager.get('license_status') activators.autotest(is_activated=True) wait_period = start + timedelta(seconds=lic_duration + 2) - datetime.now() sleep(wait_period.total_seconds()) assert not drm_manager.get('license_status') activators.autotest(is_activated=False) activators.autotest(is_activated=False) assert async_cb.was_called assert async_cb.errcode == accelize_drm.exceptions.DRMCtlrError.error_code assert search(r"License (header|MAC) check error", async_cb.message)
def test_request_timeout(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Test the request timeout is respected """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() connection_timeout = 10 request_timeout = 3 conf_json['settings']['ws_api_retry_duration'] = 0 # Disable retry conf_json['settings']['ws_connection_timeout'] = connection_timeout conf_json['settings']['ws_request_timeout'] = request_timeout conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: assert drm_manager.get('ws_connection_timeout') == connection_timeout assert drm_manager.get('ws_request_timeout') == request_timeout context = {'sleep': request_timeout + 10} set_context(context) assert get_context() == context start = datetime.now() with pytest.raises(accelize_drm.exceptions.DRMWSMayRetry) as excinfo: drm_manager.activate() end = datetime.now() assert request_timeout - 1 <= int( (end - start).total_seconds()) <= request_timeout assert search( r'\[errCode=\d+\]\s*Failed to perform HTTP request to Accelize webservice \(Timeout was reached\) : Operation timed out after [%d%d]\d+ milliseconds' % (request_timeout - 1, request_timeout), str(excinfo.value), IGNORECASE) async_cb.assert_Error( accelize_drm.exceptions.DRMWSMayRetry.error_code, 'Failed to perform HTTP request to Accelize webservice') async_cb.assert_Error(accelize_drm.exceptions.DRMWSMayRetry.error_code, HTTP_TIMEOUT_ERR_MSG) async_cb.reset()
def test_authentication_bad_token(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """Test when a bad authentication token is used""" driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(3) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server access_token = 'BAD_TOKEN' context = {'access_token': access_token} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: with pytest.raises(accelize_drm.exceptions.DRMWSError) as excinfo: drm_manager.activate() assert async_handler.get_error_code(str( excinfo.value)) == accelize_drm.exceptions.DRMWSError.error_code assert drm_manager.get('token_string') == access_token file_log_content = logfile.read() assert search(r'\bAuthentication credentials were not provided\b', file_log_content) async_cb.assert_Error(accelize_drm.exceptions.DRMWSError.error_code, 'Authentication credentials were not provided') async_cb.reset() logfile.remove()
def test_header_error_on_key(accelize_drm, conf_json, cred_json, async_handler, live_server, request, log_file_factory): """ Test a MAC error is returned if the key value in the response has been modified """ driver = accelize_drm.pytest_fpga_driver[0] # Program FPGA with lastest HDK per major number image_id = driver.fpga_image driver.program_fpga(image_id) async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() # Set initial context on the live server context = {'cnt': 0} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # Check failure is detected with pytest.raises(accelize_drm.exceptions.DRMCtlrError) as excinfo: drm_manager.activate() assert async_handler.get_error_code(str( excinfo.value)) == accelize_drm.exceptions.DRMCtlrError.error_code assert "License header check error" in str(excinfo.value) async_cb.assert_NoError()
def test_valid_derived_product(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test a valid derived product behaves as expected. """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: deriv_prod = drm_manager.get('derived_product') suffix = '_subproduct1' new_deriv_prod = deriv_prod + suffix drm_manager.set(derived_product=new_deriv_prod) assert drm_manager.get('derived_product') == new_deriv_prod # Set initial context on the live server context = {'product_suffix': suffix} set_context(context) assert get_context() == context drm_manager.activate() context = get_context() assert context['derived_product'] == new_deriv_prod drm_manager.deactivate() log_content = logfile.read() assert search('Loaded new derived product: %s' % new_deriv_prod, log_content, MULTILINE) assert get_proxy_error() is None async_cb.assert_NoError() # Same test but from config file suffix = '_subproduct2' new_deriv_prod = deriv_prod + suffix conf_json['derived_product'] = new_deriv_prod conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: assert drm_manager.get('derived_product') == new_deriv_prod # Set initial context on the live server context = {'product_suffix': suffix} set_context(context) assert get_context() == context drm_manager.activate() context = get_context() assert context['derived_product'] == new_deriv_prod drm_manager.deactivate() log_content = logfile.read() assert search('Loaded new derived product: %s' % new_deriv_prod, log_content, MULTILINE) assert get_proxy_error() is None async_cb.assert_NoError() logfile.remove()
def test_topic1_corrupted_metering2(accelize_drm, conf_json, cred_json, async_handler, live_server, request): """ Test to reproduce the metering corruption issue on pause/resume operating mode """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() activators = accelize_drm.pytest_fpga_activators[0] activators.reset_coin() activators.autotest() # Set initial context on the live server healthPeriod = 0 context = {'healthPeriod':healthPeriod} set_context(context) assert get_context() == context async_cb.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json.save() nb_run = 5 nb_pause_resume_max = 100 for r in range(nb_run): print('Run #%d' % r) with accelize_drm.DrmManager( conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback ) as drm_manager: activators.reset_coin() assert not drm_manager.get('session_status') assert not drm_manager.get('license_status') activators.autotest(is_activated=False) async_cb.assert_NoError() drm_manager.activate() start = datetime.now() assert sum(drm_manager.get('metered_data')) == 0 assert drm_manager.get('session_status') assert drm_manager.get('license_status') session_id = drm_manager.get('session_id') assert len(session_id) > 0 lic_duration = drm_manager.get('license_duration') activators.autotest(is_activated=True) for i in range(nb_pause_resume_max): print('Pause #%d' % i) try: activators.generate_coin() data = drm_manager.get('metered_data') try: activators.check_coin(data) except AssertionError: print("ERROR detected!!!!!!!!") print("1st read gives:", data) print("Waiting 5s ...") sleep(5) print("... and double check the metering") data = drm_manager.get('metered_data') print("2nd read gives:", data) activators.check_coin(drm_manager.get('metered_data')) drm_manager.deactivate(True) async_cb.assert_NoError() assert drm_manager.get('session_status') assert drm_manager.get('license_status') assert drm_manager.get('session_id') == session_id # Wait for the limit of the expiration random_wait = lic_duration wait_deadline(start, random_wait) drm_manager.activate(True) start = datetime.now() except: raise drm_manager.deactivate() assert not drm_manager.get('session_status') assert not drm_manager.get('license_status') activators.autotest(is_activated=False) assert drm_manager.get('session_id') != session_id async_cb.assert_NoError()
def test_thread_retry_on_lost_connection(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the number of expected retries and the gap between 2 retries are correct when the requests are lost on the background thread """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() retryShortPeriod = 2 retryLongPeriod = 20 licDuration = 60 requestTimeout = 5 nb_long_retry = ceil( (licDuration - retryLongPeriod - 2 * retryShortPeriod) / (retryLongPeriod + requestTimeout)) nb_short_retry = ceil( (licDuration - nb_long_retry * (retryLongPeriod + requestTimeout)) / (retryShortPeriod + requestTimeout)) nb_retry = nb_long_retry + nb_short_retry conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ conf_json['settings']['ws_retry_period_short'] = retryShortPeriod conf_json['settings']['ws_retry_period_long'] = retryLongPeriod conf_json['settings']['ws_request_timeout'] = requestTimeout logfile = log_file_factory.create(1) conf_json['settings'].update(logfile.json) conf_json.save() context = {'cnt': 0, 'timeoutSecond': licDuration} set_context(context) assert get_context() == context with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: drm_manager.activate() wait_func_true(lambda: async_cb.was_called, timeout=licDuration * 2) drm_manager.deactivate() assert async_cb.was_called assert async_cb.errcode == accelize_drm.exceptions.DRMWSTimedOut.error_code m = search(r'Timeout on License request after (\d+) attempts', async_cb.message) assert m is not None nb_attempts = int(m.group(1)) assert nb_retry == nb_attempts log_content = logfile.read() attempts_list = [ int(e) for e in findall( r'Attempt #(\d+) to obtain a new License failed with message', log_content) ] assert len(attempts_list) == nb_retry assert sorted(list(attempts_list)) == list(range(1, nb_retry + 1)) logfile.remove() async_cb.assert_Error(accelize_drm.exceptions.DRMWSTimedOut.error_code, HTTP_TIMEOUT_ERR_MSG) async_cb.reset()
def test_health_metering_data(accelize_drm, conf_json, cred_json, async_handler, live_server, ws_admin, request, log_file_factory): """ Test the metering data returned to the web service is correct. """ driver = accelize_drm.pytest_fpga_driver[0] activators = accelize_drm.pytest_fpga_activators[0] activators.reset_coin() activators.autotest() async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # Set initial context on the live server loop = 5 healthPeriod = 3 healthRetry = 0 # No retry context = { 'health_id': 0, 'healthPeriod': healthPeriod, 'healthRetry': healthRetry } set_context(context) assert get_context() == context def wait_and_check_on_next_health(drm): next_health_id = get_context()['health_id'] + 1 wait_func_true( lambda: get_context()['health_id'] >= next_health_id) session_id = drm.get('session_id') saas_data = ws_admin.get_last_metering_information(session_id) assert saas_data['session'] == session_id assert saas_data['metering'] == sum(drm.get('metered_data')) assert not drm_manager.get('license_status') drm_manager.activate() assert drm_manager.get('license_status') assert sum(drm_manager.get('metered_data')) == 0 activators.check_coin(drm_manager.get('metered_data')) wait_and_check_on_next_health(drm_manager) total_coin = 0 for i in range(loop): total_coin += activators.generate_coin() activators.check_coin(drm_manager.get('metered_data')) wait_and_check_on_next_health(drm_manager) assert sum(drm_manager.get('metered_data')) == total_coin drm_manager.deactivate() assert not drm_manager.get('license_status') assert get_proxy_error() is None async_cb.assert_NoError()
def test_segment_index(accelize_drm, conf_json, cred_json, async_handler, live_server, log_file_factory, request): """ Test the DRM Controller capacity to handle stressfully health and license requests """ driver = accelize_drm.pytest_fpga_driver[0] async_cb = async_handler.create() async_cb.reset() conf_json.reset() conf_json['licensing']['url'] = _request.url + request.function.__name__ logfile = log_file_factory.create(2) conf_json['settings'].update(logfile.json) conf_json.save() with accelize_drm.DrmManager(conf_json.path, cred_json.path, driver.read_register_callback, driver.write_register_callback, async_cb.callback) as drm_manager: # Set initial context on the live server nb_genlic = 3 healthPeriod = 300 healthRetry = 0 # no retry context = { 'nb_genlic': 0, 'healthPeriod': healthPeriod, 'healthRetry': healthRetry } set_context(context) assert get_context() == context # First, get license duration to align health period on it drm_manager.activate() lic_dur = drm_manager.get('license_duration') drm_manager.deactivate() # Adjust health period to license duration healthPeriod = lic_dur context = { 'nb_genlic': 0, 'healthPeriod': healthPeriod, 'healthRetry': healthRetry } set_context(context) assert get_context() == context drm_manager.activate() assert drm_manager.get('health_period') == healthPeriod wait_func_true(lambda: get_context()['nb_genlic'] >= nb_genlic, timeout=lic_dur * nb_genlic + 2) drm_manager.deactivate() async_cb.assert_NoError() log_content = logfile.read() segment_idx_expected = 0 for m in findall(r'"meteringFile"\s*:\s*"([^"]*)"', log_content): assert len(m) > 0 session_id = m[0:16] close_flag = m[19] segment_idx = int(m[24:32], 16) if session_id == "0000000000000000": assert close_flag == '0' assert segment_idx == 0 session_id_exp = "0000000000000000" else: if session_id_exp == "0000000000000000": session_id_exp == session_id else: assert session_id == session_id_exp assert segment_idx_expected - 1 <= segment_idx <= segment_idx_expected + 1 segment_idx_expected += 1 if close_flag == '1': segment_idx_expected = 0 assert get_proxy_error() is None logfile.remove()