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()
