def browser(self): ContainerManager.run_container(self.node, "web_driver") LOGGER.debug("Waiting for WebDriver container is up") ContainerManager.wait_for_status(self.node, "web_driver", "running") port = ContainerManager.get_container_port(self.node, "web_driver", WEB_DRIVER_REMOTE_PORT) LOGGER.debug("WebDriver port is %s", port) if self.use_tunnel: LOGGER.debug("Start auto_ssh for Selenium remote WebDriver") ContainerManager.run_container(self.node, "auto_ssh:web_driver", local_port=port, remote_port=get_free_port(), ssh_mode="-L") LOGGER.debug("Waiting for SSH tunnel container is up") ContainerManager.wait_for_status(self.node, "auto_ssh:web_driver", status="running") host = "127.0.0.1" port = int(ContainerManager.get_environ(self.node, "auto_ssh:web_driver")["SSH_TUNNEL_REMOTE"]) else: host = self.node.external_address LOGGER.debug("Waiting for port %s:%s is accepting connections", host, port) wait_for_port(host, port) time.sleep(WEB_DRIVER_CONTAINER_START_DELAY) return Remote(command_executor=f"http://{host}:{port}/wd/hub", options=ChromeOptions())
def get_kubectl_proxy(node: cluster.BaseNode) -> [str, int]: LOGGER.debug("Stop any other process listening on kubectl proxy port") node.remoter.run(f"sudo fuser -v4k {KUBECTL_PROXY_PORT}/tcp", ignore_status=True) LOGGER.debug("Start kubectl proxy in detached mode") node.remoter.run( "setsid kubectl proxy --disable-filter --accept-hosts '.*' > proxy.log 2>&1 < /dev/null & sleep 1" ) LOGGER.debug("Start auto_ssh for kubectl proxy") ContainerManager.run_container(node, KUBECTL_PROXY_CONTAINER, local_port=KUBECTL_PROXY_PORT, remote_port=get_free_port(), ssh_mode="-L") host = "127.0.0.1" port = int( ContainerManager.get_environ( node, KUBECTL_PROXY_CONTAINER)["SSH_TUNNEL_REMOTE"]) LOGGER.debug("Waiting for port %s:%s is accepting connections", host, port) wait_for_port(host, port) return host, port
def jepsen_container_run_args(self) -> dict: exposed_port = get_free_port(ports_to_try=( JEPSEN_RESULTS_PORT, 0, )) return dict(image=JEPSEN_IMAGE, entrypoint="/bin/cat", tty=True, name=f"{self.name}-jepsen", ports={ f"{JEPSEN_RESULTS_PORT}/tcp": { "HostIp": "0.0.0.0", "HostPort": exposed_port, }, })
def get_local_kubectl_proxy() -> [str, int]: LOGGER.info("Stop any other process listening on kubectl proxy port") LOCALRUNNER.sudo(f"fuser -v4k {KUBECTL_PROXY_PORT}/tcp", ignore_status=True) LOGGER.info("Start kubectl proxy in detached mode") proxy_port = get_free_port(address='127.0.0.1') LOCALRUNNER.run( f"setsid kubectl proxy --disable-filter --address '127.0.0.1' --port {proxy_port} " "--accept-hosts '.*' > proxy.log 2>&1 < /dev/null & sleep 1") def get_proxy_ip_port(): return LOCALRUNNER.run( "grep -P '^Starting' proxy.log | grep -oP '127.0.0.1:[0-9]+'" ).stdout ip_port = wait_for(get_proxy_ip_port, timeout=15, throw_exc=True) return ip_port.strip().split(':')
from textwrap import dedent import requests from sdcm.remote import LocalCmdRunner from sdcm.utils.common import list_logs_by_test_id, S3Storage, remove_files, get_free_port from sdcm.utils.decorators import retrying LOGGER = logging.getLogger(name='monitoringstack') GRAFANA_DOCKER_NAME = "agraf" PROMETHEUS_DOCKER_NAME = "aprom" ALERT_DOCKER_NAME = "aalert" GRAFANA_DOCKER_PORT = get_free_port(ports_to_try=( 3000, 0, )) ALERT_DOCKER_PORT = get_free_port(ports_to_try=( 9093, 0, )) PROMETHEUS_DOCKER_PORT = get_free_port(ports_to_try=( 9090, 0, )) COMMAND_TIMEOUT = 1800 class ErrorUploadSCTDashboard(Exception): pass
import time from textwrap import dedent import requests from sdcm.remote import LocalCmdRunner from sdcm.utils.common import list_logs_by_test_id, S3Storage, retrying, remove_files, get_free_port LOGGER = logging.getLogger(name='monitoringstack') GRAFANA_DOCKER_NAME = "agraf" PROMETHEUS_DOCKER_NAME = "aprom" ALERT_DOCKER_NAME = "aalert" GRAFANA_DOCKER_PORT = get_free_port() ALERT_DOCKER_PORT = get_free_port() PROMETHEUS_DOCKER_PORT = get_free_port() class ErrorUploadSCTDashboard(Exception): pass class ErrorUploadAnnotations(Exception): pass def restore_monitoring_stack(test_id, date_time=None): # pylint: disable=too-many-return-statements if not is_docker_available(): return False
class RemoteBrowser(): local_port = get_free_port() load_page_timeout = 30 def __init__(self, remote_web_driver, use_tunnel=True): """Instance of remote browser Create instance of remote browser for docker container remote_web_driver :param remote_web_driver: Instance of RemoteWebDriverContainer :type remote_web_driver: RemoteWebDriverContainer :param use_tunnel: use auto_ssh container to access, defaults to True :type use_tunnel: bool, optional """ self.remote_web_driver = remote_web_driver self._use_tunnel = use_tunnel self._remote_browser = self._get_remote_browser() @property def browser(self): return self._remote_browser def _get_remote_browser(self): """Get instance of remote browser Get remote browser as instance of Selenium remote webdriver running in containter described by RemoteWebDriverContainer if self._use_tunnel true, start container with auto_ssh to up tunnel to node were docker with remote selenium driver is running :returns: Opened session to remote selenium browser :rtype: {selenium.webdriver.Remote} """ chrome_options = webdriver.ChromeOptions() if not is_auto_ssh_running( self.remote_web_driver.name, self.remote_web_driver.node) and self._use_tunnel: LOGGER.debug("Start autossh for Selenium remote webdriver ") start_auto_ssh(self.remote_web_driver.name, self.remote_web_driver.node, self.remote_web_driver.remote_port, self.local_port, ssh_mode="-L") LOGGER.debug("Waiting tunnel is up") time.sleep(5) if self._use_tunnel: remote_browser_url = "http://127.0.0.1:{0.local_port}/wd/hub".format( self) else: remote_browser_url = "http://{0.external_address}:{0.remote_port}/wd/hub".format( self.remote_web_driver) driver = webdriver.Remote(command_executor=remote_browser_url, options=chrome_options) return driver def get_screenshot(self, url, screenshot_path, resolution="1920px*1280px"): """get screenshot of url and save to file screenshot_path Use remote selenium webdriver containter, open url wait page loading for time and create screenshot Arguments: node {BaseNode} -- monitor node url {str} -- url to load screenshot_path {str} -- path to save screenshot in format 1920px*1280px Keyword Arguments: resolution {str} -- [description] (default: {"1920x1280"}) """ def wait_page_loading(_): time.sleep(5) if time.time() - start_time < self.load_page_timeout: return False else: return True resolution = resolution.split("*") self._remote_browser.set_window_size(int(resolution[0][:-2]), int(resolution[1][:-2])) LOGGER.info("Get screenshot of page %s", url) self._remote_browser.get(url) start_time = time.time() try: LOGGER.debug('Wait page loading ...') WebDriverWait(self._remote_browser, self.load_page_timeout * 2).until(wait_page_loading) finally: LOGGER.debug('Create snapshot') self._remote_browser.get_screenshot_as_file(screenshot_path)