def _start_node(self, node_configuration, node_count_on_host, java_major_version):
host_name = node_configuration.ip
node_name = node_configuration.node_name
car = node_configuration.car
binary_path = node_configuration.binary_path
data_paths = node_configuration.data_paths
node_telemetry_dir = "%s/telemetry" % node_configuration.node_root_path
self.logger.info("Starting node [%s] based on car [%s].", node_name, car)
enabled_devices = self.cfg.opts("mechanic", "telemetry.devices")
telemetry_params = self.cfg.opts("mechanic", "telemetry.params")
node_telemetry = [
telemetry.FlightRecorder(telemetry_params, node_telemetry_dir, java_major_version),
telemetry.JitCompiler(node_telemetry_dir),
telemetry.Gc(node_telemetry_dir, java_major_version),
telemetry.PerfStat(node_telemetry_dir),
telemetry.DiskIo(self.metrics_store, node_count_on_host),
telemetry.CpuUsage(self.metrics_store),
telemetry.NodeEnvironmentInfo(self.metrics_store),
telemetry.IndexSize(data_paths, self.metrics_store),
telemetry.MergeParts(self.metrics_store, node_configuration.log_path),
telemetry.StartupTime(self.metrics_store),
]
t = telemetry.Telemetry(enabled_devices, devices=node_telemetry)
env = self._prepare_env(car, node_name, t)
t.on_pre_node_start(node_name)
node_process = self._start_process(env, node_name, binary_path)
node = cluster.Node(node_process, host_name, node_name, t)
self.logger.info("Node [%s] has successfully started. Attaching telemetry devices.", node_name)
t.attach_to_node(node)
self.logger.info("Telemetry devices are now attached to node [%s].", node_name)
return node
def start(self, car, binary, data_paths):
self.binary_path = binary
hosts = self.cfg.opts("client", "hosts")
client_options = self.cfg.opts("client", "options")
es = self.client_factory(hosts, client_options).create()
# Cannot enable custom telemetry devices here
t = telemetry.Telemetry(devices=[
# Be aware that some the meta-data are taken from the host system, not the container (e.g. number of CPU cores) so if the
# Docker container constrains these, the metrics are actually wrong.
telemetry.EnvironmentInfo(es, self.metrics_store),
telemetry.NodeStats(es, self.metrics_store),
telemetry.IndexStats(es, self.metrics_store),
telemetry.DiskIo(self.metrics_store),
telemetry.CpuUsage(self.metrics_store)
])
c = cluster.Cluster(hosts, [], t)
self._start_process(cmd="docker-compose -f %s up" % self.binary_path, node_name="rally0")
logger.info("Docker container has successfully started. Checking if REST API is available.")
if wait_for_rest_layer(es):
logger.info("REST API is available. Attaching telemetry devices to cluster.")
t.attach_to_cluster(c)
logger.info("Telemetry devices are now attached to the cluster.")
else:
logger.error("REST API layer is not yet available. Forcefully terminating cluster.")
self.stop(c)
raise exceptions.LaunchError("Elasticsearch REST API layer is not available. Forcefully terminated cluster.")
return c
def _start_node(self, node_configuration, node_count_on_host):
host_name = node_configuration.ip
node_name = node_configuration.node_name
car = node_configuration.car
binary_path = node_configuration.binary_path
data_paths = node_configuration.data_paths
node_telemetry_dir = "%s/telemetry" % node_configuration.node_root_path
java_major_version, java_home = java_resolver.java_home(car, self.cfg)
self.logger.info("Starting node [%s] based on car [%s].", node_name,
car)
enabled_devices = self.cfg.opts("mechanic", "telemetry.devices")
telemetry_params = self.cfg.opts("mechanic", "telemetry.params")
node_telemetry = [
telemetry.DiskIo(self.metrics_store, node_count_on_host,
node_telemetry_dir, node_name),
telemetry.NodeEnvironmentInfo(self.metrics_store),
telemetry.IndexSize(data_paths, self.metrics_store),
telemetry.MergeParts(self.metrics_store,
node_configuration.log_path),
telemetry.StartupTime(self.metrics_store),
]
t = telemetry.Telemetry(enabled_devices, devices=node_telemetry)
env = self._prepare_env(car, node_name, java_home, t)
t.on_pre_node_start(node_name)
node_pid = self._start_process(binary_path, env)
node = cluster.Node(node_pid, host_name, node_name, t)
self.logger.info("Attaching telemetry devices to node [%s].",
node_name)
t.attach_to_node(node)
return node
def _start_node(self, node, car, es, binary_path):
node_name = self._node_name(node)
host_name = socket.gethostname()
enabled_devices = self.cfg.opts("mechanic", "telemetry.devices")
node_telemetry = [
telemetry.FlightRecorder(self.node_telemetry_dir),
telemetry.JitCompiler(self.node_telemetry_dir),
telemetry.Gc(self.node_telemetry_dir),
telemetry.PerfStat(self.node_telemetry_dir),
telemetry.DiskIo(self.metrics_store),
telemetry.CpuUsage(self.metrics_store),
telemetry.EnvironmentInfo(es, self.metrics_store),
]
t = telemetry.Telemetry(enabled_devices, devices=node_telemetry)
env = self._prepare_env(car, node_name, t)
cmd = self.prepare_cmd(car, node_name)
process = self._start_process(cmd, env, node_name, binary_path)
node = cluster.Node(process, host_name, node_name, t)
logger.info("Cluster node [%s] has successfully started. Attaching telemetry devices to node." % node_name)
t.attach_to_node(node)
logger.info("Telemetry devices are now attached to node [%s]." % node_name)
return node
def _start_node(self, host, node, es):
node_name = self._node_name(node)
p = self._start_process(cmd="docker-compose -f %s up" % self.binary_path, node_name=node_name)
# only support a subset of telemetry for Docker hosts (specifically, we do not allow users to enable any devices)
node_telemetry = [
telemetry.DiskIo(self.metrics_store),
telemetry.CpuUsage(self.metrics_store),
telemetry.EnvironmentInfo(es, self.metrics_store)
]
t = telemetry.Telemetry(devices=node_telemetry)
return cluster.Node(p, host["host"], node_name, t)
def start(self, node_configurations):
nodes = []
for node_configuration in node_configurations:
node_name = node_configuration.node_name
host_name = node_configuration.ip
binary_path = node_configuration.binary_path
self.binary_paths[node_name] = binary_path
self._start_process(binary_path)
# only support a subset of telemetry for Docker hosts
# (specifically, we do not allow users to enable any devices)
node_telemetry = [
telemetry.DiskIo(self.metrics_store, len(node_configurations)),
telemetry.NodeEnvironmentInfo(self.metrics_store)
]
t = telemetry.Telemetry(devices=node_telemetry)
nodes.append(cluster.Node(0, host_name, node_name, t))
return nodes
def _start_node(self, node_configuration, node_count_on_host):
host_name = node_configuration.ip
node_name = node_configuration.node_name
car = node_configuration.car
binary_path = node_configuration.binary_path
data_paths = node_configuration.data_paths
node_telemetry_dir = os.path.join(node_configuration.node_root_path,
"telemetry")
java_major_version, java_home = java_resolver.java_home(car, self.cfg)
telemetry.add_metadata_for_node(self.metrics_store, node_name,
host_name)
self.logger.info("Starting node [%s] based on car [%s].", node_name,
car)
enabled_devices = self.cfg.opts("mechanic", "telemetry.devices")
telemetry_params = self.cfg.opts("mechanic", "telemetry.params")
node_telemetry = [
telemetry.FlightRecorder(telemetry_params, node_telemetry_dir,
java_major_version),
telemetry.JitCompiler(node_telemetry_dir),
telemetry.Gc(node_telemetry_dir, java_major_version),
telemetry.DiskIo(self.metrics_store, node_count_on_host,
node_telemetry_dir, node_name),
telemetry.IndexSize(data_paths, self.metrics_store),
telemetry.StartupTime(self.metrics_store),
]
t = telemetry.Telemetry(enabled_devices, devices=node_telemetry)
env = self._prepare_env(car, node_name, java_home, t)
t.on_pre_node_start(node_name)
node_pid = self._start_process(binary_path, env)
node = cluster.Node(node_pid, host_name, node_name, t)
self.logger.info("Attaching telemetry devices to node [%s].",
node_name)
t.attach_to_node(node)
return node
def start(self, node_configurations):
nodes = []
for node_configuration in node_configurations:
node_name = node_configuration.node_name
host_name = node_configuration.ip
binary_path = node_configuration.binary_path
node_telemetry_dir = os.path.join(
node_configuration.node_root_path, "telemetry")
self.binary_paths[node_name] = binary_path
self._start_process(binary_path)
# only support a subset of telemetry for Docker hosts
# (specifically, we do not allow users to enable any devices)
node_telemetry = [
telemetry.DiskIo(self.metrics_store, len(node_configurations),
node_telemetry_dir, node_name),
]
t = telemetry.Telemetry(devices=node_telemetry)
telemetry.add_metadata_for_node(self.metrics_store, node_name,
host_name)
nodes.append(cluster.Node(0, host_name, node_name, t))
return nodes
def _start_node(self, node, car, es):
node_name = self._node_name(node)
host_name = socket.gethostname()
node_telemetry = [
telemetry.FlightRecorder(self.cfg, self.metrics_store),
telemetry.JitCompiler(self.cfg, self.metrics_store),
telemetry.Gc(self.cfg, self.metrics_store),
telemetry.PerfStat(self.cfg, self.metrics_store),
telemetry.DiskIo(self.cfg, self.metrics_store),
telemetry.CpuUsage(self.cfg, self.metrics_store),
telemetry.EnvironmentInfo(self.cfg, es, self.metrics_store),
]
t = telemetry.Telemetry(self.cfg, devices=node_telemetry)
env = self._prepare_env(car, node_name, t)
cmd = self.prepare_cmd(car, node_name)
process = self._start_process(cmd, env, node_name)
node = cluster.Node(process, host_name, node_name, t)
t.attach_to_node(node)
return node
def start(self, car):
# hardcoded for the moment, should actually be identical to internal launcher
# Only needed on Mac:
# hosts = [{"host": process.run_subprocess_with_output("docker-machine ip default")[0].strip(), "port": 9200}]
hosts = [{"host": "localhost", "port": 9200}]
client_options = self.cfg.opts("launcher", "client.options")
# unified client config
self.cfg.add(config.Scope.benchmark, "client", "hosts", hosts)
self.cfg.add(config.Scope.benchmark, "client", "options",
client_options)
es = self.client_factory(hosts, client_options).create()
t = telemetry.Telemetry(
self.cfg,
devices=[
# Be aware that some the meta-data are taken from the host system, not the container (e.g. number of CPU cores) so if the
# Docker container constrains these, the metrics are actually wrong.
telemetry.EnvironmentInfo(self.cfg, es, self.metrics_store),
telemetry.NodeStats(self.cfg, es, self.metrics_store),
telemetry.IndexStats(self.cfg, es, self.metrics_store),
telemetry.DiskIo(self.cfg, self.metrics_store),
telemetry.CpuUsage(self.cfg, self.metrics_store)
])
distribution_version = self.cfg.opts("source",
"distribution.version",
mandatory=False)
install_dir = self._install_dir()
io.ensure_dir(install_dir)
java_opts = ""
if car.heap:
java_opts += "-Xms%s -Xmx%s " % (car.heap, car.heap)
if car.java_opts:
java_opts += car.java_opts
vars = {
"es_java_opts":
java_opts,
"container_memory_gb":
"%dg" % (convert.bytes_to_gb(psutil.virtual_memory().total) // 2),
"es_data_dir":
"%s/data" % install_dir,
"es_version":
distribution_version
}
docker_cfg = self._render_template_from_file(vars)
logger.info("Starting Docker container with configuration:\n%s" %
docker_cfg)
docker_cfg_path = self._docker_cfg_path()
with open(docker_cfg_path, "wt") as f:
f.write(docker_cfg)
c = cluster.Cluster([], t)
self._start_process(cmd="docker-compose -f %s up" % docker_cfg_path,
node_name="rally0")
# Wait for a little while: Plugins may still be initializing although the node has already started.
time.sleep(10)
t.attach_to_cluster(c)
logger.info("Successfully started Docker container")
return c
