def prepare_benchmark()

in esrally/driver/driver.py [0:0]

• 51 lines of code
• 13 McCabe index (conditional complexity)

    def prepare_benchmark(self, t):
        self.track = t
        self.challenge = select_challenge(self.config, self.track)
        self.quiet = self.config.opts("system", "quiet.mode", mandatory=False, default_value=False)
        downsample_factor = int(self.config.opts("reporting", "metrics.request.downsample.factor", mandatory=False, default_value=1))
        self.metrics_store = metrics.metrics_store(cfg=self.config, track=self.track.name, challenge=self.challenge.name, read_only=False)

        self.sample_post_processor = SamplePostprocessor(
            self.metrics_store, downsample_factor, self.track.meta_data, self.challenge.meta_data
        )

        es_clients = self.create_es_clients()
        self.default_sync_es_client = es_clients["default"]

        skip_rest_api_check = self.config.opts("mechanic", "skip.rest.api.check")
        uses_static_responses = self.config.opts("client", "options").uses_static_responses
        serverless_mode = convert.to_bool(self.config.opts("driver", "serverless.mode", mandatory=False, default_value=False))
        serverless_operator = convert.to_bool(self.config.opts("driver", "serverless.operator", mandatory=False, default_value=False))
        build_hash = None
        if skip_rest_api_check:
            self.logger.info("Skipping REST API check as requested explicitly.")
        elif uses_static_responses:
            self.logger.info("Skipping REST API check as static responses are used.")
        else:
            if serverless_mode and not serverless_operator:
                self.logger.info("Skipping REST API check while targetting serverless cluster with a public user.")
            else:
                self.wait_for_rest_api(es_clients)
            self.driver_actor.cluster_details = self.retrieve_cluster_info(es_clients)
            if serverless_mode:
                # overwrite static serverless version number
                self.driver_actor.cluster_details["version"]["number"] = "serverless"
                if serverless_operator:
                    # overwrite build hash if running as operator
                    build_hash = self.retrieve_build_hash_from_nodes_info(es_clients)
                    self.logger.info("Retrieved actual build hash [%s] from serverless cluster.", build_hash)
                    self.driver_actor.cluster_details["version"]["build_hash"] = build_hash

        # Avoid issuing any requests to the target cluster when static responses are enabled. The results
        # are not useful and attempts to connect to a non-existing cluster just lead to exception traces in logs.
        self.prepare_telemetry(
            es_clients,
            enable=not uses_static_responses,
            index_names=self.track.index_names(),
            data_stream_names=self.track.data_stream_names(),
            build_hash=build_hash,
            serverless_mode=serverless_mode,
            serverless_operator=serverless_operator,
        )

        for host in self.config.opts("driver", "load_driver_hosts"):
            host_config = {
                # for simplicity we assume that all benchmark machines have the same specs
                "cores": num_cores(self.config)
            }
            if host != "localhost":
                host_config["host"] = net.resolve(host)
            else:
                host_config["host"] = host

            self.load_driver_hosts.append(host_config)

        self.driver_actor.prepare_track([h["host"] for h in self.load_driver_hosts], self.config, self.track)