private void rateControlledRunLoop() {
m_lastRequestTime = System.currentTimeMillis();
while (true) {
boolean bp = false;
/*
* If there is back pressure don't send any requests. Update the
* last request time so that a large number of requests won't
* queue up to be sent when there is no longer any back
* pressure.
*/
try {
m_voltClient.backpressureBarrier();
} catch (InterruptedException e1) {
throw new RuntimeException();
}
final long now = System.currentTimeMillis();
/*
* Generate the correct number of transactions based on how much
* time has passed since the last time transactions were sent.
*/
final long delta = now - m_lastRequestTime;
if (delta > 0) {
final int transactionsToCreate = (int) (delta * m_txnsPerMillisecond);
if (transactionsToCreate < 1) {
Thread.yield();
continue;
}
for (int ii = 0; ii < transactionsToCreate; ii++) {
try {
bp = !runOnce();
if (bp) {
m_lastRequestTime = now;
break;
}
} catch (final IOException e) {
return;
}
}
} else {
Thread.yield();
}
m_lastRequestTime = now;
}
}
@Override
public void run() {
if (m_txnRate == -1) {
if (m_sampler != null) {
m_sampler.start();
}
try {
runLoop();
} catch (final IOException e) {
} catch (final InterruptedException e) {
}
} else {
System.err.println(
"Running rate controlled m_txnRate == "
+ m_txnRate
+ " m_txnsPerMillisecond == "
+ m_txnsPerMillisecond);
System.err.flush();
rateControlledRunLoop();
}
if (m_exitOnCompletion) {
System.exit(0);
}
}
public void answerPoll() {
final StringBuilder txncounts = new StringBuilder();
synchronized (m_counts) {
for (int i = 0; i < m_counts.length; ++i) {
txncounts.append(",");
txncounts.append(m_countDisplayNames[i]);
txncounts.append(",");
txncounts.append(m_counts[i].get());
}
}
// For now, sum the latency buckets and send them across
// with the magic key "@@ClientLatencyBuckets" Delimit
// the buckets with "--", to avoid the normalized commas
// whitespace characters. Gah. Hack.
VoltTable clientRTTLatencies = m_voltClient.getClientRTTLatencies();
long[] latencies = latencySummaryHelper(clientRTTLatencies);
txncounts.append(", @@ClientLatencyBuckets,");
for (int i = 0; i < latencies.length; i++) {
txncounts.append(latencies[i]);
txncounts.append("--");
}
VoltTable clusterRTTLatencies = m_voltClient.getClusterRTTLatencies();
latencies = latencySummaryHelper(clusterRTTLatencies);
txncounts.append(", @@ClusterLatencyBuckets,");
for (int i = 0; i < latencies.length; i++) {
txncounts.append(latencies[i]);
txncounts.append("--");
}
System.out.printf(
"%d,%s%s\n", System.currentTimeMillis(), m_controlState.display, txncounts.toString());
}
/**
* Derived classes implementing a main that will be invoked at the start of the app should call
* this main to instantiate themselves
*
* @param clientClass Derived class to instantiate
* @param args
* @param startImmediately Whether to start the client thread immediately or not.
*/
public static void main(
final Class<? extends ClientMain> clientClass,
final String args[],
final boolean startImmediately) {
try {
final Constructor<? extends ClientMain> constructor =
clientClass.getConstructor(new Class<?>[] {new String[0].getClass()});
final ClientMain clientMain = constructor.newInstance(new Object[] {args});
if (startImmediately) {
final ControlWorker worker = clientMain.new ControlWorker();
worker.start();
// Wait for the worker to finish
worker.join();
} else {
clientMain.start();
}
} catch (final Exception e) {
e.printStackTrace();
System.exit(-1);
}
}
public void answerWithError() {
System.out.printf("%d,%s,%s\n", System.currentTimeMillis(), m_controlState.display, m_reason);
}
public void run() {
String command = "";
final InputStreamReader reader = new InputStreamReader(System.in);
final BufferedReader in = new BufferedReader(reader);
// transition to ready and send ready message
if (m_controlState == ControlState.PREPARING) {
System.out.printf("%d,%s\n", System.currentTimeMillis(), ControlState.READY.display);
m_controlState = ControlState.READY;
} else {
System.err.println("Error - not starting prepared!");
System.err.println(m_controlState.display + " " + m_reason);
}
while (true) {
try {
command = in.readLine();
} catch (final IOException e) {
// Hm. quit?
System.err.println("Error on standard input: " + e.getMessage());
System.exit(-1);
}
if (command.equalsIgnoreCase("START")) {
if (m_controlState != ControlState.READY) {
setState(ControlState.ERROR, "START when not READY.");
answerWithError();
continue;
}
answerStart();
m_controlState = ControlState.RUNNING;
} else if (command.equalsIgnoreCase("POLL")) {
if (m_controlState != ControlState.RUNNING) {
setState(ControlState.ERROR, "POLL when not RUNNING.");
answerWithError();
continue;
}
answerPoll();
} else if (command.equalsIgnoreCase("STOP")) {
if (m_controlState == ControlState.RUNNING) {
try {
if (m_sampler != null) {
m_sampler.setShouldStop();
m_sampler.join();
}
m_voltClient.close();
if (m_checkTables) {
checkTables();
}
} catch (InterruptedException e) {
System.exit(0);
}
System.exit(0);
}
System.err.println("Error: STOP when not RUNNING");
System.exit(-1);
} else {
System.err.println("Error on standard input: unknown command " + command);
System.exit(-1);
}
}
}