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)
