def test_no_error_monit_log(self, settings):
"""
Test to check that, when running the container, systemd starts postgresql and there is no error in the monit logs.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
# message in syslog when there are no errors
no_error_status = "No entries"
# docker inspect --format='{{.State.Status}} container
check_status = docker.bake("inspect", "--format='{{.State.StartedAt}}'", container_name)
logger.debug(check_status)
last_started_date = dateutil.parser.parse(check_status().stdout.rstrip()).replace(tzinfo=None)
time.sleep(3)
# check in journalctl if there are any errors since the container last started
get_monit_log = docker.bake("exec", container_name, "journalctl", "-u", "monit", "--since", last_started_date,
"-p", "err", "-b")
logger.debug(get_monit_log)
monit_log = get_monit_log().stdout.decode("utf-8")
logger.debug(monit_log)
assert re.search(no_error_status, monit_log) is not None
def test_monit_restarts_stopped_services(self, test_settings):
"""
Test to check if monit restarts a stopped service of the container.
:param test_settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = test_settings['keycloak_container']['container_name']
services = test_settings['keycloak_container']['services']
# logger.info("The following services are tested: ")
# for service in services:
# logger.info(service['name'])
for service in services:
service_name = service['name']
max_timeout = service['timeout']
stop_service = docker.bake("exec", "-i", container_name,
"systemctl", "stop", service_name)
logger.debug(stop_service)
stop_service()
tic_tac = 0
service_is_up = False
while (tic_tac < max_timeout) and (service_is_up == False):
# check if monit started the service
time.sleep(1)
check_service = docker.bake("exec", "-i", container_name,
"systemctl", "status",
service_name)
logger.info(
"Check to see if {service} started after {time} seconds".
format(service=service_name, time=tic_tac))
logger.debug(check_service)
try:
service_status = check_service().exit_code
logger.debug(service_status)
if (service_status == 0):
service_is_up = True
logger.info("{service} is running".format(
service=service_name))
except Exception as e:
tic_tac = tic_tac + 1
assert service_is_up == True
def test_no_error_monit_log(self, test_settings):
"""
Test to check that when running the container systemd starts all the services of the container and there is no
error in the monit logs.
As keycloak takes time to start and keycloak bridge is dependent on it, we check if there is no error in the
monit logs after the time keycloak started (and not since the container started).
:param test_settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = test_settings['keycloak_container']['container_name']
# message in syslog when there are no errors
no_error_status = "No entries"
# check the time when the keycloak service has started
service_name = "keycloak"
keycloak_is_running = False
while not keycloak_is_running:
check_service = docker.bake("exec", "-i", container_name,
"systemctl", "status", service_name)
logger.info("Check to see if {service} started".format(
service=service_name))
logger.debug(check_service)
try:
service_status = check_service().exit_code
logger.debug(service_status)
if service_status == 0:
keycloak_is_running = True
logger.info(
"{service} is running".format(service=service_name))
keycloak_starting_time = datetime.datetime.now()
except Exception as e:
pass
# check in journalctl if there are any errors since the keycloak service started
get_monit_log = docker.bake("exec", container_name, "journalctl", "-u",
"monit", "--since", keycloak_starting_time,
"-p", "err", "-b")
logger.debug(get_monit_log)
monit_log = get_monit_log().stdout.decode("utf-8")
logger.debug(monit_log)
assert re.search(no_error_status, monit_log) is not None
def test_is_systemd_running_keycloak(self, test_settings):
"""
Test if keycloak is currently running under systemd management
:return:
"""
# Settings
path_to_run_from = '/root'
check_keycloak_status = (
"/usr/bin/busctl", "get-property", "org.freedesktop.systemd1",
"/org/freedesktop/systemd1/unit/keycloak_2eservice",
"org.freedesktop.systemd1.Unit", "ActiveState")
docker_container_name = test_settings['keycloak_container'][
'container_name']
print(docker_container_name)
# Challange value
systemctl_keycloak_validation = "active"
# Test
docker_exec_busctl_get_ActiveState = docker.bake("exec",
'-i',
docker_container_name,
check_keycloak_status,
_iter=True)
logger.debug(docker_exec_busctl_get_ActiveState)
state = docker_exec_busctl_get_ActiveState()
logger.debug(state)
assert re.search(systemctl_keycloak_validation,
state.stdout.decode("utf-8")) is not None
def test_systemd_running_keycloak_bridge(self, test_settings):
"""
Test to check if systemd is running keycloak bridge.
:param test_settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = test_settings['keycloak_container']['container_name']
command_keycloak_bridge = (
"busctl", "get-property", "org.freedesktop.systemd1",
"/org/freedesktop/systemd1/unit/keycloak_5fbridge_2eservice",
"org.freedesktop.systemd1.Unit", "ActiveState")
active_status = '"active"'
# docker exec -it busctl get-property
check_service = docker.bake("exec", "-i", container_name,
command_keycloak_bridge)
logger.debug(check_service)
# check the return value
keycloak_bridge_status = check_service().stdout.decode("utf-8")
logger.debug(keycloak_bridge_status)
status = re.search(active_status, keycloak_bridge_status)
assert status is not None
def test_systemd_restarts_monit(self, test_settings):
"""
Test to check that if monit is down then systemd will restart it.
:param test_settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = test_settings['keycloak_container']['container_name']
service_name = "monit"
max_timeout = test_settings['keycloak_container']['monit_timeout']
# kill monit
stop_service = docker.bake("exec", "-i", container_name, "systemctl",
"kill", service_name)
logger.debug(stop_service)
stop_service()
tic_tac = 0
monit_is_up = False
while (tic_tac < max_timeout) and (not monit_is_up):
# check if systemd starts monit
time.sleep(1)
check_service = docker.bake("exec", "-i", container_name,
"systemctl", "status", service_name)
logger.info(
"Check to see if {service} started after {time} seconds".
format(service=service_name, time=tic_tac))
logger.debug(check_service)
try:
monit_status = check_service().exit_code
if (monit_status == 0):
monit_is_up = True
logger.info(
"{service} is running".format(service=service_name))
except Exception as e:
tic_tac = tic_tac + 1
assert monit_is_up == True
def _set_sh_docker(name):
from sh import docker
_exec_ = "exec -t {name!s} bash --login -c"
_run_ = ""
if name not in list_containers():
# start/run conteiner
raise NotImplementedError
isissh = docker.bake(_exec_.format(name=name).split())
return isissh
def bake(container):
"""
Return a 'sh' instance running inside 'container'
"""
exec_ = "exec -t {container!s} " + SHELL_COMMAND
if container not in containers():
log.error(f"Container '{container}' not available.")
return None
sh_ = docker.bake(exec_.format(container=container).split())
return sh_
def test_monit_restarts_killed_postgresl(self, settings):
"""
Test to check if monit restarts a killed postgresql.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
service_name = settings['service_name']
max_timeout = settings['psql_timeout']
# kill postgresql
stop_service = docker.bake("exec", "-i", container_name, "systemctl", "kill", service_name)
logger.debug(stop_service)
stop_service()
tic_tac = 0
psql_is_up = False
while (tic_tac < max_timeout) and (not psql_is_up):
# check if monit started postgresql
time.sleep(1)
check_service = docker.bake("exec", "-i", container_name, "systemctl", "status", service_name)
logger.info("Check to see if {service} started after {time} seconds".format(service=service_name, time=tic_tac))
logger.debug(check_service)
try:
postgresql_status = check_service().exit_code
if postgresql_status == 0:
psql_is_up = True
logger.info("{service} is running".format(service=service_name))
except Exception as e:
tic_tac = tic_tac + 1
assert psql_is_up == True
def test_container_running(self, settings):
"""
Test to check if the container is running.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
running_status = 'running'
container_name = settings['container_name']
# docker inspect --format='{{.State.Status}} container
check_status = docker.bake("inspect", "--format='{{.State.Status}}'", container_name)
logger.debug(check_status)
status = re.search(running_status, check_status().stdout.decode("utf-8"))
assert status is not None
def test_container_exposed_ports(self, settings):
"""
Test to check if the correct ports are exposed.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
ports = settings['ports']
check_ports = docker.bake("inspect", "--format='{{.Config.ExposedPorts}}'", container_name)
logger.debug(check_ports)
exposed_ports = check_ports().stdout.decode("utf-8")
logger.debug(exposed_ports)
for port in ports:
assert re.search(port, exposed_ports) is not None
def test_monit_always_restarts(self, settings):
"""
Test to check if monit is configured to always restart.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
command_monit = (
"busctl", "get-property", "org.freedesktop.systemd1", "/org/freedesktop/systemd1/unit/monit_2eservice",
"org.freedesktop.systemd1.Service", "Restart")
restart_status = '"always"'
# docker exec -it busctl get-property
check_monit_restart = docker.bake("exec", "-i", container_name, command_monit)
logger.debug(check_monit_restart)
# check the return value
monit_restart = check_monit_restart().stdout.decode("utf-8")
logger.debug(monit_restart)
status = re.search(restart_status, monit_restart)
assert status is not None
def test_systemd_running_postgresql(self, settings):
"""
Test to check if systemd is running postgresql.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
command_postgresql = (
"busctl", "get-property", "org.freedesktop.systemd1", "/org/freedesktop/systemd1/unit/postgresql_2eservice",
"org.freedesktop.systemd1.Unit", "ActiveState")
active_status = '"active"'
# docker exec -it busctl get-property
check_service = docker.bake("exec", "-i", container_name, command_postgresql)
logger.debug(check_service)
# check the return value
postgresql_status = check_service().stdout.decode("utf-8")
logger.debug(postgresql_status)
status = re.search(active_status, postgresql_status)
assert status is not None
BRIDGE = 'swarm'
CONSUL = '10.100.1.17'
CONSUL_PORT = 8500
CONSUL_LOG = '/var/log/consul'
NETWORK = 'owl'
hosts = [MASTER] + AGENTS
machines = [ ssh.bake(host) for host in hosts ]
consul = "/homes/sys/bholt/bin/consul"
swarm_url = fmt("tcp://#{MASTER}:#{SWARM_PORT}")
swarm = docker.bake(host=swarm_url)
master = ssh.bake(MASTER)
LIVE = {'_out': sys.stdout, '_err': sys.stderr}
def docker(host):
return sh.docker.bake("--host=tcp://{}:{}".format(host, DOCKER_PORT))
def on(host):
return ssh.bake(host)
def start(args=None, opt=None):
def test_data_consistency(self, settings, psql_settings):
"""
Test to check that the modifications done in Postgresql are present after the container was stopped.
:param settings: settings of the container, e.g. container name, service name, etc.
:return:
"""
container_name = settings['container_name']
service_name = settings['service_name']
try:
logger.info("connecting to postgres with user {user}".format(user=psql_settings['user']))
with psycopg2.connect(host=psql_settings['host'], user=psql_settings['user'],
password=psql_settings['password']) as con:
with con.cursor() as cur:
# create an user
username = "******"
cur.execute("CREATE USER {user};".format(user=username))
logger.debug("CREATE USER {user}".format(user=username))
con.commit()
except Exception as e:
logger.debug(e)
if con:
con.rollback()
pytest.fail("Error {error}".format(error=e))
finally:
if con:
con.close()
logger.info("closed connection to postgresql")
stop_container = docker.bake("stop", container_name)
logger.debug(stop_container)
stop_container()
restart_container = docker.bake("restart", container_name)
logger.debug(restart_container)
restart_container()
psql_is_up = False
while not psql_is_up:
time.sleep(1)
check_service = docker.bake("exec", "-i", container_name, "systemctl", "status", service_name)
logger.debug(check_service)
try:
postgresql_status = check_service().exit_code
if postgresql_status == 0:
psql_is_up = True
logger.info("{service} is running".format(service=service_name))
except Exception as e:
pass
try:
logger.info("connecting again to postgres with user {user}".format(user=psql_settings['user']))
with psycopg2.connect(host=psql_settings['host'], user=psql_settings['user'],
password=psql_settings['password']) as con:
with con.cursor() as cur:
# check if the user created exists
logger.debug("SELECT 1 FROM pg_roles WHERE rolname='{user}'".format(user=username))
cur.execute("SELECT 1 FROM pg_roles WHERE rolname='{user}'".format(user=username))
assert cur.rowcount == 1
# remove the created user
cur.execute("DROP USER {user};".format(user=username))
logger.debug("DROP USER {user};".format(user=username))
cur.execute("SELECT 1 FROM pg_roles WHERE rolname='{user}'".format(user=username))
assert cur.rowcount == 0
con.commit()
except Exception as e:
logger.debug(e)
if con:
con.rollback()
pytest.fail("Error {error}".format(error=e))
finally:
if con:
con.close()
logger.info("closed connection to postgresql")
