def get_vm(desired_caps):
platform = get_platform(desired_caps)
vm = None
for _ in generator_wait_for(lambda: vm, timeout=config.GET_VM_TIMEOUT):
vm = current_app.pool.get_vm(platform)
if vm:
break
if not vm:
raise CreationException(
"Timeout while waiting for vm with platform %s" % platform)
yield vm
for _ in generator_wait_for(lambda: vm.ready,
timeout=config.GET_VM_TIMEOUT):
yield vm
if not vm.ready:
vm.delete(try_to_rebuild=False)
raise CreationException('Timeout while building vm %s (platform: %s)' %
(vm.name, platform))
log.info('Got vm for request with params: %s' % vm.info)
yield vm
def start_selenium_session(request, session, port):
status, headers, body = None, None, None
for attempt_start in range(3):
log.info(
"Attempt %s. Starting selenium-server-standalone session for %s" %
(attempt_start, session.id))
log.debug(
"with %s %s %s %s" %
(request.method, request.path, request.headers, request.data))
wrapped_make_request = add_sub_step(session, session.make_request)
for status, headers, body in wrapped_make_request(
port,
RequestHelper(request.method, request.path, request.headers,
request.data)):
yield status, headers, body
if status == httplib.OK:
log.info("SUCCESS start selenium-server-standalone status for %s" %
session.id)
break
else:
log.info("Attempt %s to start selenium session was FAILED. "
"Trying again..." % attempt_start)
if status != httplib.OK:
log.info("FAILED start selenium-server-standalone status "
"for %s - %s : %s" % (session.id, status, body))
raise CreationException("Failed to start selenium session: %s" % body)
yield status, headers, body
def _wait_for_activated_service(self):
ping_retry = 1
while not self.ready and not self.deleted:
self.refresh_endpoint()
if self.is_spawning:
log.info("Container {} is spawning...".format(self.name))
elif self.is_created:
if not self.__container.ip:
log.info("Waiting ip for {}".format(self.name))
continue
self.ip = self.__container.ip
if self.ping_vm() and self.selenium_is_ready:
self.set_ready(True)
break
if ping_retry > config.VM_PING_RETRY_COUNT:
p = config.VM_PING_RETRY_COUNT * config.PING_TIMEOUT
log.info("Container {} pings more than {} seconds...".format(self.name, p))
self.delete(try_to_rebuild=True)
break
ping_retry += 1
elif self.is_broken or not self.status:
raise CreationException("Container {} has not been created.".format(self.name))
else:
log.warning("Unknown status {} for container {}".format(self.status, self.name))
return self.ready
def selenium_status(request, session, port):
parts = request.path.split("/")
parts[-1] = "status"
status_cmd = "/".join(parts)
status, headers, body, selenium_status_code = None, None, None, None
for attempt in range(3):
log.info("Attempt %s. Getting selenium-server-standalone status "
"for %s" % (attempt, session.id))
wrapped_make_request = add_sub_step(session, session.make_request)
for status, headers, body in wrapped_make_request(
port, RequestHelper("GET", status_cmd)):
yield status, headers, body
selenium_status_code = json.loads(body).get("status", None)
if selenium_status_code == 0:
log.info("SUCCESS get selenium-server-standalone status for %s" %
session.id)
break
else:
log.info("Attempt %s to get selenium status was FAILED. "
"Trying again..." % attempt)
if selenium_status_code != 0:
log.info("FAIL get selenium-server-standalone status for %s" %
session.id)
raise CreationException("Failed to get selenium status: %s" % body)
yield status, headers, body
def start_session(request, session):
log.info("Start preparing selenium session for {}".format(session))
status, headers, body = None, None, None
ping_endpoint_before_start_session(session, session.endpoint.bind_ports)
yield status, headers, body
selenium_status(request, session)
yield status, headers, body
if session.run_script:
startup_script(session)
status, headers, body = start_selenium_session(request, session)
json_body = utils.to_json(body)
if json_body.get("sessionId"):
selenium_session = json_body.get("sessionId")
elif json_body.get("value", {}).get("sessionId"):
selenium_session = json_body.get("value").get("sessionId")
else:
raise CreationException(
"SessionId not found in selenium response {}".format(json_body))
log.debug('Selenium real session_id {} for session {}'.format(
selenium_session, session.id))
session.refresh()
session.selenium_session = selenium_session
session.save()
body = set_body_session_id(body, session.id)
headers["Content-Length"] = len(body)
yield status, headers, body
def get_network_name(self, network_id):
if network_id:
for net in self.network_client.list_networks().get('networks', []):
if net['id'] == network_id:
return net['name']
else:
raise CreationException('Can\'t return network name because '
'network_id was %s' % str(network_id))
def check_to_exist_ip(session, tries=10, timeout=5):
i = 0
while True:
if session.endpoint_ip is not None:
return session.endpoint_ip
else:
if i > tries:
raise CreationException('Error: VM %s have not ip address' %
session.endpoint_name)
i += 1
log.info('IP is %s for VM %s, wait for %ss. before next try...' %
(session.endpoint_ip, session.endpoint_name, timeout))
time.sleep(timeout)
def ping_endpoint_before_start_session(session, ports):
ip = check_to_exist_ip(session)
log.info("Starting ping: {ip}:{ports}".format(ip=ip, ports=str(ports)))
_ping = partial(network_utils.ping, ip)
def check():
return all(map(_ping, ports))
for _ in generator_wait_for(check, config.PING_TIMEOUT):
yield False
result = map(_ping, ports)
if not all(result):
fails = [port for port, res in zip(ports, result) if res is False]
raise CreationException("Failed to ping ports %s" % str(fails))
if session.closed:
raise CreationException("Session was closed while ping")
log.info("Ping successful: {ip}:{ports}".format(ip=ip, ports=str(ports)))
yield True
def get_platform(desired_caps):
platform = desired_caps.get('platform', None)
if hasattr(config, "PLATFORM") and config.PLATFORM:
log.info('Using %s. Desired platform %s has been ignored.' %
(config.PLATFORM, platform))
platform = config.PLATFORM
desired_caps["platform"] = platform
if isinstance(platform, unicode):
platform = platform.encode('utf-8')
if not platform:
raise CreationException(
'Platform parameter for new endpoint not found in dc')
if not current_app.pool.platforms.check_platform(platform):
raise PlatformException('No such platform %s' % platform)
return platform
def selenium_status(request, session, port):
parts = request.path.split("/")
parts[-1] = "status"
status_cmd = "/".join(parts)
status, headers, body, selenium_status_code = None, None, None, None
log.info("Getting selenium-server-standalone status for %s" % session.id)
wrapped_make_request = add_sub_step(session, session.make_request)
for status, headers, body in wrapped_make_request(
port, RequestHelper("GET", status_cmd)):
yield status, headers, body
selenium_status_code = json.loads(body).get("status", None)
if selenium_status_code != 0:
log.info("FAILED get selenium-server-standalone status for %s" %
session.id)
raise CreationException("Failed to get selenium status: %s" % body)
log.info("SUCCESS get selenium-server-standalone status for %s" %
session.id)
yield status, headers, body
def start_selenium_session(request, session, port):
status, headers, body = None, None, None
log.info("Starting selenium-server-standalone session for %s" % session.id)
log.debug("with %s %s %s %s" %
(request.method, request.path, request.headers, request.data))
wrapped_make_request = add_sub_step(session, session.make_request)
for status, headers, body in wrapped_make_request(
port,
RequestHelper(request.method, request.path, request.headers,
request.data)):
yield status, headers, body
if status != httplib.OK:
log.info("FAILED start selenium-server-standalone status "
"for %s - %s : %s" % (session.id, status, body))
raise CreationException("Failed to start selenium session: %s" % body)
log.info("SUCCESS start selenium-server-standalone status for %s" %
session.id)
yield status, headers, body
def get_session():
profiler.register_get_session_call()
dc = commands.get_desired_capabilities(request)
matched_platform, provider_id = current_app.get_matched_platforms(dc)
if not matched_platform:
raise SessionException("Cannot match platform for DesiredCapabilities: {}".format(dc))
session = Session(platform=matched_platform, dc=dc, provider_id=provider_id)
request.session = session
log.info("New session {}({}) on provider {} with dc: {}".format(session.id, session.name, provider_id, dc))
yield session
start_time = time.time()
while not session.endpoint_id:
time.sleep(constants.GET_SESSION_SLEEP_TIME)
if time.time() - start_time >= config.GET_VM_TIMEOUT:
raise CreationException("Timeout getting endpoint for {}".format(session))
session.refresh()
yield session
session.run()
yield session
def start_selenium_session(request, session):
status, headers, body = None, None, None
log.info("Starting selenium-server-standalone session for {}".format(
session.id))
log.debug("with %s %s %s %s" %
(request.method, request.path, request.headers, request.data))
wrapped_make_request = add_sub_step(session, session.make_request)
for status, headers, body in wrapped_make_request(
session.endpoint.selenium_port,
network_utils.RequestHelper(request.method, request.path,
request.headers, request.data),
timeout=constants.CREATE_SESSION_REQUEST_TIMEOUT):
yield status, headers, body
if status != httplib.OK:
log.info("FAILED start selenium-server-standalone status "
"for %s - %s : %s" % (session.id, status, body))
raise CreationException("Failed to start selenium session: %s" % body)
log.info("SUCCESS start selenium-server-standalone session for {}".format(
session.id))
yield status, headers, body
def create(self):
if self.ready:
log.info("Creation {} was successful".format(self.name))
else:
raise CreationException("Creation {} was failed".format(self.name))
def prepare_endpoint(
self,
session,
get_endpoint_attempts=constants.GET_ENDPOINT_ATTEMPTS):
with self.app_context():
session.set_status("preparing")
attempt, wait_time = 0, 2
while self.running:
attempt += 1
wait_time *= 2
session.refresh()
if session.closed:
log.warning(
"Attempt {} was aborted because session {} was closed".
format(attempt, session.id))
break
if session.endpoint:
log.warning(
"Attempt {} was aborted because session {} already have endpoint_id"
.format(attempt, session.id, session.endpoint_id))
break
log.info("Try to find endpoint {} for {}. Attempt {}".format(
session.platform, session, attempt))
try:
_endpoint = self.pool.get_vm(session.platform, session.dc)
if not self.running:
if _endpoint:
_endpoint.delete()
break
if self.running and _endpoint:
profiler.register_success_get_endpoint(attempt)
session.set_endpoint(_endpoint)
log.info(
"Attempt {} to find endpoint {} for session {} was succeed"
.format(attempt, session.platform, session))
break
if _endpoint and getattr(_endpoint, "ready", False):
raise CreationException(
"Got non-ready endpoint or None: {}".format(
_endpoint))
else:
raise EndpointUnreachableError(
"Endpoint wasn't returned, was returned None")
except EndpointUnreachableError as e:
log.debug(
"Attempt {} to get endpoint for session {} was failed: {}"
.format(attempt, session.id, e.message))
except:
log.exception(
"Attempt {} to get endpoint for session {} was failed".
format(attempt, session.id))
if attempt < get_endpoint_attempts:
log.debug(
"Waiting {} seconds before next attempt {} to get endpoint"
.format(wait_time, attempt + 1))
time.sleep(wait_time)
else:
profiler.register_fail_get_endpoint()
break
session.refresh()
if not session.endpoint_id and session.is_preparing:
session.set_status("waiting")
