def test_update_failover_server(self):
"""
Client is initially set up against server A, and then receives an update
containing a multi-server configuration, with server B as primary and A
secondary. Server B does not, however, expect any clients and will trigger
"failover" to server A.
To create the necessary configuration I use a state script to modify the
/etc/mender/mender.conf
"""
if not env.host_string:
execute(self.test_update_failover_server,
hosts=get_mender_clients())
return
valid_image = conftest.get_valid_image()
tmp_image = valid_image.split(".")[0] + "-failover-image.ext4"
try:
logger.info("Creating failover sample image.")
shutil.copy(valid_image, tmp_image)
conf = image.get_mender_conf(tmp_image)
if conf == None:
raise SystemExit("Could not retrieve mender.conf")
conf["Servers"] = [{"ServerURL": "https://docker.mender-failover.io"}, \
{"ServerURL": conf["ServerURL"]}]
conf.pop("ServerURL")
image.replace_mender_conf(tmp_image, conf)
update_image_successful(install_image=tmp_image)
finally:
os.remove(tmp_image)
def test_signed_artifact_success(self):
if not env.host_string:
execute(self.test_signed_artifact_success,
hosts=get_mender_clients())
return
update_image_successful(install_image=conftest.get_valid_image(), signed=True)
def test_update_jwt_expired(self):
"""Upload a device with two consecutive upgrade images"""
if not env.host_string:
execute(self.test_update_jwt_expired, hosts=get_mender_clients())
return
update_image_successful(install_image=conftest.get_valid_image())
def test_double_update(self):
"""Upload a device with two consecutive upgrade images"""
if not env.host_string:
execute(self.test_double_update, hosts=get_mender_clients())
return
update_image_successful()
update_image_successful()
def test_update_no_compression(self):
"""Uploads an uncompressed artifact, and runs the whole udpate process."""
if not env.host_string:
execute(self.test_update_no_compression,
hosts=get_mender_clients())
return
update_image_successful(install_image=conftest.get_valid_image(),
compression_type="none")
def test_failed_updated_and_valid_update(self):
"""Upload a device with a broken image, followed by a valid image"""
if not env.host_string:
execute(self.test_failed_updated_and_valid_update,
hosts=get_mender_clients())
return
update_image_failed()
update_image_successful(install_image=conftest.get_valid_image())
def test_forced_update_check_from_client(self):
"""Upload a device with a broken image, followed by a valid image"""
if not env.host_string:
execute(self.test_forced_update_check_from_client,
hosts=get_mender_clients())
return
# Give the image a really large wait interval.
sedcmd = "sed -i.bak 's/%s/%s/' /etc/mender/mender.conf" % (
"\(.*PollInter.*:\)\( *[0-9]*\)", "\\1 1800")
out = run(sedcmd)
if out.return_code != 0:
logger.error(out)
pytest.fail(
"failed to set a large polling interval for the client.")
run("systemctl restart mender")
def deployment_callback():
logger.info("Running pre deployment callback function")
wait_count = 0
# Match the log template six times to make sure the client is truly sleeping.
catcmd = "journalctl -u mender --output=cat"
template = run(catcmd)
while True:
logger.info("sleeping...")
logger.info("wait_count: %d" % wait_count)
time.sleep(10)
out = run(catcmd)
if out == template:
wait_count += 1
# Only return if the client has been idling in check-wait for a minute.
if wait_count == 6:
return
continue
# Update the matching template
template = run(catcmd)
wait_count = 0
def deployment_triggered_callback():
output = run("mender --check-update")
if output.return_code != 0:
logger.error(output)
pytest.fail("Forcing the update check failed")
logger.info("mender client has forced an update check")
update_image_successful(
install_image=conftest.get_valid_image(),
pre_deployment_callback=deployment_callback,
deployment_triggered_callback=deployment_triggered_callback)
def perform_update(self):
if not env.host_string:
execute(self.perform_update, hosts=get_mender_clients())
return
update_image_successful(install_image=conftest.get_valid_image())
