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