Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
"""
Extracts user tags into a structured dict
:param user_tags: A string containing user tags (tags separated by comma, key and value separated by colon).
:return: A dict containing user tags. If no user tags are given, an empty dict is returned.
"""
user_tags_dict = {}
if user_tags and user_tags.strip() != "":
try:
for user_tag in user_tags.split(","):
user_tag_key, user_tag_value = user_tag.split(":")
user_tags_dict[user_tag_key] = user_tag_value
except ValueError:
msg = "User tag keys and values have to separated by a ':'. Invalid value [%s]" % user_tags
logging.getLogger(__name__).exception(msg)
raise exceptions.SystemSetupError(msg)
return user_tags_dict
def _url_for(self, user_defined_key, default_key, mandatory=True):
try:
if user_defined_key in self.cfg:
url_template = self.cfg[user_defined_key]
else:
url_template = self.cfg[default_key]
except KeyError:
if mandatory:
raise exceptions.SystemSetupError("Neither config key [{}] nor [{}] is defined.".format(user_defined_key, default_key))
else:
return None
return self._substitute_vars(url_template)
def _path_for(team_root_path, team_member_type):
root_path = os.path.join(team_root_path, team_member_type, "v{}".format(TEAM_FORMAT_VERSION))
if not os.path.exists(root_path):
raise exceptions.SystemSetupError("Path {} for {} does not exist.".format(root_path, team_member_type))
return root_path
return None
else:
return None
# this has to be consistent with _checked_env_vars()
specific_env_var = "JAVA{}_HOME".format(major)
generic_env_var = "JAVA_HOME"
java_home = do_resolve(specific_env_var, major)
if java_home:
return java_home
else:
java_home = do_resolve(generic_env_var, major)
if java_home:
return java_home
elif mandatory:
raise exceptions.SystemSetupError("Neither {} nor {} point to a JDK {} installation.".
format(specific_env_var, generic_env_var, major))
else:
return None
else:
filtered_tasks = cfg.opts("track", "exclude.tasks")
exclude = True
current_track = reader.read(track_name, repo.track_file(track_name), track_dir)
current_track = filter_tasks(current_track, filters_from_filtered_tasks(filtered_tasks), exclude)
plugin_reader = TrackPluginReader(track_dir)
current_track.has_plugins = plugin_reader.can_load()
if cfg.opts("track", "test.mode.enabled"):
return post_process_for_test_mode(current_track)
else:
return current_track
except FileNotFoundError:
logging.getLogger(__name__).exception("Cannot load track [%s]", track_name)
raise exceptions.SystemSetupError("Cannot load track %s. List the available tracks with %s list tracks." %
(track_name, PROGRAM_NAME))
except BaseException:
logging.getLogger(__name__).exception("Cannot load track [%s]", track_name)
raise
def __init__(self, track_path):
if not os.path.exists(track_path):
raise exceptions.SystemSetupError("Track path %s does not exist" % track_path)
if os.path.isdir(track_path):
self.track_name = io.basename(track_path)
self._track_dir = track_path
self._track_file = os.path.join(track_path, "track.json")
if not os.path.exists(self._track_file):
raise exceptions.SystemSetupError("Could not find track.json in %s" % track_path)
elif os.path.isfile(track_path):
if io.has_extension(track_path, ".json"):
self._track_dir = io.dirname(track_path)
self._track_file = track_path
self.track_name = io.splitext(io.basename(track_path))[0]
else:
raise exceptions.SystemSetupError("%s has to be a JSON file" % track_path)
else:
raise exceptions.SystemSetupError("%s is neither a file nor a directory" % track_path)
request_meta_data = {"success": True}
except elasticsearch.TransportError as e:
total_ops = 0
total_ops_unit = "ops"
request_meta_data = {
"success": False,
"error-type": "transport",
"error-description": e.error
}
# The ES client will sometimes return string like "N/A" or "TIMEOUT" for connection errors.
if isinstance(e.status_code, int):
request_meta_data["http-status"] = e.status_code
except KeyError as e:
logger.exception("Cannot execute runner [%s]; most likely due to missing parameters." % str(runner))
msg = "Cannot execute [%s]. Provided parameters are: %s. Error: [%s]." % (str(runner), list(params.keys()), str(e))
raise exceptions.SystemSetupError(msg)
if abort_on_error and not request_meta_data["success"]:
msg = "Request returned an error:\n\n"
msg += "Error type: %s\n" % request_meta_data.get("error-type", "Unknown")
description = request_meta_data.get("error-description")
if description:
msg += "Description: %s\n" % description
raise exceptions.RallyAssertionError(msg)
return total_ops, total_ops_unit, request_meta_data
def download(self, base_url, target_path, size_in_bytes, detail_on_missing_root_url):
file_name = os.path.basename(target_path)
if not base_url:
raise exceptions.DataError("%s and it cannot be downloaded because no base URL is provided."
% detail_on_missing_root_url)
if self.offline:
raise exceptions.SystemSetupError("Cannot find %s. Please disable offline mode and retry again." % target_path)
data_url = "%s/%s" % (base_url, file_name)
try:
io.ensure_dir(os.path.dirname(target_path))
if size_in_bytes:
size_in_mb = round(convert.bytes_to_mb(size_in_bytes))
self.logger.info("Downloading data from [%s] (%s MB) to [%s].", data_url, size_in_mb, target_path)
else:
self.logger.info("Downloading data from [%s] to [%s].", data_url, target_path)
# we want to have a bit more accurate download progress as these files are typically very large
progress = net.Progress("[INFO] Downloading data for track %s" % self.track_name, accuracy=1)
net.download(data_url, target_path, size_in_bytes, progress_indicator=progress)
progress.finish()
self.logger.info("Downloaded data from [%s] to [%s].", data_url, target_path)
except urllib.error.HTTPError as e:
logger.info("Creating new actor system with system base [%s] on coordinator node.", system_base)
# if we try to join we can only run on the coordinator...
return thespian.actors.ActorSystem(system_base, logDefs=log.load_configuration(), capabilities={"coordinator": True})
elif prefer_local_only:
coordinator = True
if system_base != "multiprocQueueBase":
coordinator_ip = "127.0.0.1"
local_ip = "127.0.0.1"
else:
coordinator_ip = None
local_ip = None
else:
if system_base not in ("multiprocTCPBase", "multiprocUDPBase"):
raise exceptions.SystemSetupError("Rally requires a network-capable system base but got [%s]." % system_base)
if not coordinator_ip:
raise exceptions.SystemSetupError("coordinator IP is required")
if not local_ip:
raise exceptions.SystemSetupError("local IP is required")
# always resolve the public IP here, even if a DNS name is given. Otherwise Thespian will be unhappy
local_ip = net.resolve(local_ip)
coordinator_ip = net.resolve(coordinator_ip)
coordinator = local_ip == coordinator_ip
capabilities = {"coordinator": coordinator}
if local_ip:
# just needed to determine whether to run benchmarks locally
capabilities["ip"] = local_ip
if coordinator_ip:
# Make the coordinator node the convention leader
capabilities["Convention Address.IPv4"] = "%s:1900" % coordinator_ip
logger.info("Starting actor system with system base [%s] and capabilities [%s].", system_base, capabilities)