com.hazelcast.simulator.hazelcast4plus.Hazelcast4PlusDriver Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2008-2016, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.simulator.hazelcast4plus;
import com.hazelcast.client.HazelcastClient;
import com.hazelcast.client.config.ClientConfig;
import com.hazelcast.client.config.XmlClientConfigBuilder;
import com.hazelcast.config.Config;
import com.hazelcast.config.XmlConfigBuilder;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.partition.Partition;
import com.hazelcast.partition.PartitionService;
import com.hazelcast.simulator.agent.workerprocess.WorkerParameters;
import com.hazelcast.simulator.coordinator.ConfigFileTemplate;
import com.hazelcast.simulator.coordinator.registry.AgentData;
import com.hazelcast.simulator.utils.BashCommand;
import com.hazelcast.simulator.drivers.Driver;
import org.apache.log4j.Logger;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import static com.hazelcast.simulator.utils.CommonUtils.sleepMillisThrowException;
import static com.hazelcast.simulator.utils.FileUtils.getConfigurationFile;
import static com.hazelcast.simulator.utils.FileUtils.getUserDir;
import static java.lang.String.format;
public class Hazelcast4PlusDriver extends Driver {
private static final long PARTITION_WARMUP_TIMEOUT_NANOS = TimeUnit.MINUTES.toNanos(5);
private static final int PARTITION_WARMUP_SLEEP_INTERVAL_MILLIS = 500;
private static final Logger LOGGER = Logger.getLogger(Hazelcast4PlusDriver.class);
private HazelcastInstance hazelcastInstance;
@Override
public WorkerParameters loadWorkerParameters(String workerType, int agentIndex) {
Map s = new HashMap<>(properties);
s.remove("CONFIG");
if ("hazelcast-enterprise4".equals(get("DRIVER"))) {
String licenceKey = get("LICENCE_KEY");
if (licenceKey == null) {
throw new IllegalStateException("licenceKey needs to be set with 'hazelcast-enterprise4' as driver");
}
}
WorkerParameters params = new WorkerParameters()
.setAll(s)
.set("WORKER_TYPE", workerType)
.set("file:log4j.xml", loadLog4jConfig());
if ("member".equals(workerType)) {
loadMemberWorkerParameters(params);
} else if ("javaclient".equals(workerType)) {
loadJavaClientWorkerParameters(params);
} else if ("litemember".equals(workerType)) {
loadLiteMemberWorkerParameters(params);
} else {
throw new IllegalArgumentException(String.format("Unsupported workerType [%s]", workerType));
}
return params;
}
private void loadMemberWorkerParameters(WorkerParameters params) {
params.set("JVM_OPTIONS", loadJvmOptions("MEMBER_ARGS"))
.set("file:hazelcast.xml", initMemberHzConfig(false))
.set("file:worker.sh", loadWorkerScript("member"));
}
private void loadLiteMemberWorkerParameters(WorkerParameters params) {
params.set("JVM_OPTIONS", loadJvmOptions("CLIENT_ARGS"))
.set("file:hazelcast.xml", initMemberHzConfig(true))
.set("file:worker.sh", loadWorkerScript("litemember"));
}
private void loadJavaClientWorkerParameters(WorkerParameters params) {
params.set("JVM_OPTIONS", loadJvmOptions("CLIENT_ARGS"))
.set("file:client-hazelcast.xml", initClientHzConfig())
.set("file:worker.sh", loadWorkerScript("javaclient"));
}
private String loadJvmOptions(String argsProperty) {
return get(argsProperty, "");
}
@Override
public HazelcastInstance getDriverInstance() {
return hazelcastInstance;
}
public String initMemberHzConfig(boolean liteMember) {
String config = loadMemberConfig(liteMember);
ConfigFileTemplate template = new ConfigFileTemplate(config);
String licenseKey = get("LICENCE_KEY");
template.addEnvironment("licenseKey", licenseKey);
template.addEnvironment(properties);
//template.withAgents(componentRegistry);
template.addReplacement("",
createAddressConfig("member", agents, get("HAZELCAST_PORT")));
if (licenseKey != null) {
template.addReplacement("", format("%s ", licenseKey));
}
String manCenterURL = get("MANAGEMENT_CENTER_URL");
if (!"none".equals(manCenterURL) && (manCenterURL.startsWith("http://") || manCenterURL.startsWith("https://"))) {
String updateInterval = get("MANAGEMENT_CENTER_UPDATE_INTERVAL");
String updateIntervalAttr = (updateInterval.isEmpty()) ? "" : " update-interval=\"" + updateInterval + '"';
template.addReplacement("",
format("%n %s%n" + " %n",
updateIntervalAttr, manCenterURL));
}
if (liteMember) {
template.addReplacement("", "");
}
return template.render();
}
private String loadMemberConfig(boolean liteMember) {
String config = get("CONFIG");
if (config != null) {
return config;
}
if (liteMember && new File("litemember-hazelcast.xml").exists()) {
return loadConfigFile("Hazelcast lite-member configuration", "litemember-hazelcast.xml");
} else {
return loadConfigFile("Hazelcast member configuration", "hazelcast.xml");
}
}
public String initClientHzConfig() {
String config = loadClientConfig();
ConfigFileTemplate template = new ConfigFileTemplate(config);
//template.withAgents(componentRegistry);
String licenseKey = get("LICENCE_KEY");
template.addEnvironment("licenseKey", licenseKey);
template.addEnvironment(properties);
template.addReplacement("",
createAddressConfig("address", agents, get("CLIENT_PORT", get("HAZELCAST_PORT"))));
if (licenseKey != null) {
template.addReplacement("", format("%s ", licenseKey));
}
return template.render();
}
private String loadClientConfig() {
String config = get("CONFIG");
if (config != null) {
return config;
}
return loadConfigFile("Hazelcast client configuration", "client-hazelcast.xml");
}
public static String createAddressConfig(String tagName, List agents, String port) {
StringBuilder members = new StringBuilder();
for (AgentData agent : agents) {
String hostAddress = agent.getPrivateAddress();
members.append(format("<%s>%s:%s%n", tagName, hostAddress, port, tagName));
}
return members.toString();
}
@Override
public void install() {
String cloud = get("CLOUD_PROVIDER");
if ("embedded".equals(cloud)) {
return;
}
String versionSpec = get("VERSION_SPEC");
LOGGER.info("Installing versionSpec [" + versionSpec + "] on " + agents.size() + " agents...");
String publicIps = "";
if (!"local".equals(cloud)) {
publicIps = AgentData.publicAddressesString(agents);
}
String driver = get("DRIVER");
String driverInstallScript = null;
if (driver.contains("enterprise")) {
driverInstallScript = "install-hazelcast-enterprise4plus.sh";
} else {
driverInstallScript = "install-hazelcast4plus.sh";
}
String installFile = getConfigurationFile(driverInstallScript, driver).getPath();
LOGGER.info("Installing '" + driver + "' version '" + versionSpec + "' on Agents using " + installFile);
new BashCommand(installFile)
.addParams(get("SESSION_ID"), versionSpec, publicIps)
.addEnvironment(properties)
.execute();
LOGGER.info("Successfully installed '" + driver + "'");
LOGGER.info("Install successful!");
}
@Override
public void startDriverInstance() throws Exception {
String workerType = get("WORKER_TYPE");
LOGGER.info(format("%s HazelcastInstance starting", workerType));
if ("javaclient".equals(workerType)) {
File configFile = new File(getUserDir(), "client-hazelcast.xml");
XmlClientConfigBuilder configBuilder = new XmlClientConfigBuilder(configFile);
ClientConfig clientConfig = configBuilder.build();
hazelcastInstance = HazelcastClient.newHazelcastClient(clientConfig);
} else {
File configFile = new File(getUserDir(), "hazelcast.xml");
XmlConfigBuilder configBuilder = new XmlConfigBuilder(configFile.getAbsolutePath());
Config config = configBuilder.build();
hazelcastInstance = Hazelcast.newHazelcastInstance(config);
}
LOGGER.info(format("%s HazelcastInstance started", workerType));
warmupPartitions(hazelcastInstance);
LOGGER.info("Warmed up partitions");
}
@Override
public void close() throws IOException {
LOGGER.info("Stopping HazelcastInstance...");
if (hazelcastInstance != null) {
hazelcastInstance.shutdown();
}
}
public static void warmupPartitions(HazelcastInstance hazelcastInstance) {
LOGGER.info("Waiting for partition warmup");
PartitionService partitionService = hazelcastInstance.getPartitionService();
long started = System.nanoTime();
for (Partition partition : partitionService.getPartitions()) {
if (System.nanoTime() - started > PARTITION_WARMUP_TIMEOUT_NANOS) {
throw new IllegalStateException("Partition warmup timeout. Partitions didn't get an owner in time");
}
while (partition.getOwner() == null) {
LOGGER.debug("Partition owner is not yet set for partitionId: " + partition.getPartitionId());
sleepMillisThrowException(PARTITION_WARMUP_SLEEP_INTERVAL_MILLIS);
}
}
LOGGER.info("Partitions are warmed up successfully");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy