def test_metering_limits_on_licensing_thread(accelize_drm, conf_json, cred_json, async_handler, log_file_factory, ws_admin):
"""
Test an error is returned by the async error function and the design is locked when the limit is reached.
"""
driver = accelize_drm.pytest_fpga_driver[0]
async_cb = async_handler.create()
activators = accelize_drm.pytest_fpga_activators[0]
activators.reset_coin()
activators.autotest()
async_cb.reset()
conf_json.reset()
logfile = log_file_factory.create(2)
conf_json['settings'].update(logfile.json)
conf_json.save()
cred_json.set_user('accelize_accelerator_test_03')
accelize_drm.clean_metering_env(cred_json, ws_admin)
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('license_type') == 'Floating/Metering'
assert not drm_manager.get('license_status')
drm_manager.activate()
start = datetime.now()
assert drm_manager.get('drm_license_type') == 'Floating/Metering'
assert drm_manager.get('license_status')
assert sum(drm_manager.get('metered_data')) == 0
lic_duration = drm_manager.get('license_duration')
sleep(int(lic_duration/2) + 1)
activators[0].generate_coin(1000)
activators.check_coin(drm_manager.get('metered_data'))
# Wait right before lock
wait_deadline(start, 3*lic_duration-3)
assert drm_manager.get('license_status')
activators.autotest(is_activated=True)
wait_deadline(start, 3*lic_duration+3)
assert not drm_manager.get('license_status')
activators.autotest(is_activated=False)
# Verify asynchronous callback has been called
assert async_cb.was_called
assert 'Metering Web Service error 400' in async_cb.message
assert 'DRM WS request failed' in async_cb.message
assert search(r'\\"Entitlement Limit Reached\\" with .+ for \[email protected]', async_cb.message)
assert 'You have reached the maximum quantity of 1000. usage_unit for metered entitlement (licensed)' in async_cb.message
assert async_cb.errcode == accelize_drm.exceptions.DRMWSReqError.error_code
drm_manager.deactivate()
assert not drm_manager.get('license_status')
activators.autotest(is_activated=False)
logfile.remove()
def test_topic1_corrupted_metering(accelize_drm, conf_json, cred_json, async_handler):
"""
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()
cred_json.set_user('accelize_accelerator_test_02')
async_cb.reset()
conf_json.reset()
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:
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')
assert len(drm_manager.get('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.reset_coin()
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)
activators.autotest(is_activated=True)
async_cb.assert_NoError()
assert drm_manager.get('session_status')
assert drm_manager.get('license_status')
# Wait for the limit of the expiration
random_wait = lic_duration*2
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_metered_pause_resume_long_time(accelize_drm, conf_json, cred_json, async_handler, log_file_factory):
"""
Test no error occurs in normal start/stop metering mode during a long period of time
"""
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()
cred_json.set_user('accelize_accelerator_test_02')
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:
nb_pause_resume = 2
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')
wait_numbers = [lic_duration*2-2,lic_duration*2+2]
activators.autotest(is_activated=True)
for i in range(nb_pause_resume):
activators.generate_coin()
activators.check_coin(drm_manager.get('metered_data'))
wait_func_true(lambda: drm_manager.get('num_license_loaded') == 2, 10)
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 randomly at the limit of the expiration
random_wait = choice(wait_numbers)
wait_deadline(start, random_wait)
drm_manager.activate(True)
if random_wait > lic_duration*2:
start = datetime.now()
assert drm_manager.get('session_id') != session_id
activators.reset_coin()
session_id = drm_manager.get('session_id')
else:
start += timedelta(seconds=lic_duration)
assert drm_manager.get('session_id') == session_id, 'after loop #%d' % i
assert drm_manager.get('session_status')
assert drm_manager.get('session_id') == session_id
assert drm_manager.get('license_status')
activators.autotest(is_activated=True)
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()
logfile.remove()
def test_metered_pause_resume_from_new_object(accelize_drm, conf_json, conf_json_second,
cred_json, async_handler, log_file_factory):
"""
Test no error occurs in normal pause/resume metering mode when the resume
is executed from a new object and before the license expires
"""
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()
cred_json.set_user('accelize_accelerator_test_02')
logfile1 = log_file_factory.create(2)
conf_json['settings'].update(logfile1.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_manager1:
assert not drm_manager1.get('session_status')
assert not drm_manager1.get('license_status')
activators.autotest(is_activated=False)
drm_manager1.activate()
start = datetime.now()
assert sum(drm_manager1.get('metered_data')) == 0
assert drm_manager1.get('session_status')
assert drm_manager1.get('license_status')
session_id = drm_manager1.get('session_id')
assert len(session_id) > 0
activators.autotest(is_activated=True)
lic_duration = drm_manager1.get('license_duration')
assert sum(drm_manager1.get('metered_data')) == 0
activators.generate_coin()
activators.check_coin(drm_manager1.get('metered_data'))
assert sum(drm_manager1.get('metered_data')) != 0
# Wait enough time to be sure the 2nd license has been provisioned
wait_deadline(start, lic_duration/2)
drm_manager1.deactivate(True)
assert drm_manager1.get('session_status')
assert drm_manager1.get('license_status')
assert drm_manager1.get('session_id') == session_id
activators.autotest(is_activated=True)
async_cb.assert_NoError()
sleep(1)
# Create new object
logfile2 = log_file_factory.create(2)
conf_json_second['settings'].update(logfile2.json)
conf_json_second.save()
drm_manager2 = accelize_drm.DrmManager(
conf_json_second.path,
cred_json.path,
driver.read_register_callback,
driver.write_register_callback,
async_cb.callback
)
assert drm_manager1 != drm_manager2
assert drm_manager2.get('session_status')
assert drm_manager2.get('license_status')
activators.autotest(is_activated=True)
assert drm_manager2.get('session_id') == ''
# Resume session
drm_manager2.activate(True)
assert drm_manager2.get('session_status')
assert drm_manager2.get('license_status')
activators.autotest(is_activated=True)
activators.check_coin(drm_manager2.get('metered_data'))
# Wait for license renewal
sleep(lic_duration+2)
assert drm_manager2.get('session_id') == session_id
assert drm_manager2.get('license_duration') == lic_duration
activators.generate_coin()
activators.check_coin(drm_manager2.get('metered_data'))
drm_manager2.deactivate()
assert not drm_manager2.get('session_status')
assert not drm_manager2.get('license_status')
assert drm_manager2.get('session_id') == ''
activators.autotest(is_activated=False)
logfile2.remove()
logfile1.remove()
async_cb.assert_NoError()
def run_test_on_design(accelize_drm, design_name, conf_json, cred_json,
async_handler, log_file_factory, axiclk_freq_ref,
drmclk_freq_ref):
# Program board with design
ref_designs = accelize_drm.pytest_ref_designs
try:
fpga_image = ref_designs.get_image_id(design_name)
except:
pytest.skip(
f"Could not find refesign name '{design_name}' for driver '{accelize_drm.pytest_fpga_driver_name}'"
)
driver = accelize_drm.pytest_fpga_driver[0]
driver.program_fpga(fpga_image)
accelize_drm.scanActivators()
# Run test
async_cb = async_handler.create()
async_cb.reset()
activators = accelize_drm.pytest_fpga_activators[0]
activators.reset_coin()
activators.autotest()
logfile = log_file_factory.create(1)
conf_json['settings'].update(logfile.json)
conf_json['drm']['frequency_mhz'] = drmclk_freq_ref
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 not drm_manager.get('session_status')
assert not drm_manager.get('license_status')
assert drm_manager.get('session_id') == ''
activators.autotest(is_activated=False)
activators.generate_coin(5)
activators.check_coin()
# Start session
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
activators.autotest(is_activated=True)
lic_duration = drm_manager.get('license_duration')
activators.generate_coin()
activators.check_coin(drm_manager.get('metered_data'))
# Wait until 2 licenses are provisioned
conftest.wait_func_true(
lambda: drm_manager.get('num_license_loaded') == 2, lic_duration)
# Pause session
drm_manager.deactivate(True)
assert drm_manager.get('session_status')
assert drm_manager.get('license_status')
assert drm_manager.get('session_id') == session_id
activators.autotest(is_activated=True)
# Wait right before license expiration
conftest.wait_deadline(start, 2 * lic_duration - 3)
assert drm_manager.get('session_status')
assert drm_manager.get('license_status')
assert drm_manager.get('session_id') == session_id
activators.autotest(is_activated=True)
# Wait expiration
conftest.wait_deadline(start, 2 * lic_duration + 2)
assert drm_manager.get('session_status')
assert drm_manager.get('session_id') == session_id
assert not drm_manager.get('license_status')
activators.autotest(is_activated=False)
activators.generate_coin()
activators.check_coin(drm_manager.get('metered_data'))
# Resume session
drm_manager.activate(True)
assert drm_manager.get('session_status')
assert drm_manager.get('session_id') != session_id
assert drm_manager.get('license_status')
activators.reset_coin()
activators.autotest(is_activated=True)
activators.generate_coin()
activators.check_coin(drm_manager.get('metered_data'))
# Stop session
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') == ''
# Check result
log_content = logfile.read()
# Check API calls
assert search(r"Calling Impl public constructor", log_content, IGNORECASE)
assert search(r"Calling 'activate' with 'resume_session_request'=false",
log_content, IGNORECASE)
assert search(r"Calling 'deactivate' with 'pause_session_request'=true",
log_content, IGNORECASE)
assert search(r"Calling 'activate' with 'resume_session_request'=true",
log_content, IGNORECASE)
assert search(r"Calling 'deactivate' with 'pause_session_request'=false",
log_content, IGNORECASE)
# Check DRM Controller frequencies
drmclk_match = search(
r'Frequency detection of drm_aclk counter after .+ => estimated frequency = (\d+) MHz',
log_content)
drmclk_freq_measure = int(drmclk_match.group(1))
assert drmclk_freq_ref * 0.9 < drmclk_freq_measure < drmclk_freq_ref * 1.1
axiclk_match = search(
r'Frequency detection of s_axi_aclk counter after .+ => estimated frequency = (\d+) MHz',
log_content)
axiclk_freq_measure = int(axiclk_match.group(1))
assert axiclk_freq_ref * 0.9 < axiclk_freq_measure < axiclk_freq_ref * 1.1
async_cb.assert_NoError()
# Return logfile handler for more specific verification
logfile.remove()
return log_content