Subversion Repositories general

Compare Revisions

Ignore whitespace Rev 1127 → Rev 1128

/httpbench/trunk/src/ak/httpbench/HttpBench.java
1,5 → 1,8
package ak.httpbench;
 
import java.util.List;
import java.util.ArrayList;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
9,15 → 12,182
 
public class HttpBench
{
private static Log log = LogFactory.getLog(HttpBench.class);
 
public static void main(String[] args)
throws Exception
{
(new HttpThread(null, new String[] { "http://sun/" } )).run();
HttpBench hb = new HttpBench();
 
if(hb.parseParams(args))
hb.run();
}
 
// config
private int threadNumber = 10;
private int requestNumber = 50;
private int requestPerConnection = 0;
private int sleepMin = 0;
private int sleepMax = 1000; // 1s
private int timeout = 60000; // 1min
private String firstUrl = null;
private List urls = new ArrayList();
 
private int parseInt(String s, String prefix, String errorMsg)
throws Exception
{
try {
return Integer.parseInt(s.substring(prefix.length()));
}
catch(Exception ex) {
log.error(errorMsg);
throw ex;
}
}
 
private boolean parseParams(String[] args)
throws Exception
{
try {
for(int i = 0; i< args.length; i++) {
String s = args[i];
if(s.startsWith("thr=")) {
threadNumber = parseInt(s, "thr=",
"Cannot get number of threads from " + s);
}
else if(s.startsWith("req=")) {
requestNumber = parseInt(s, "req=",
"Cannot get number of requests from " + s);
}
else if(s.startsWith("rpc=")) {
requestPerConnection = parseInt(s, "rpc=",
"Cannot get number of requests per connection from " + s);
}
else if(s.startsWith("sleepMin=")) {
sleepMin = parseInt(s, "sleepMin=",
"Cannot get min sleep from " + s);
}
else if(s.startsWith("timeout=")) {
timeout = parseInt(s, "timeout=",
"Cannot get timeout from " + s);
}
else if(s.startsWith("sleepMax=")) {
sleepMax = parseInt(s, "sleepMax=",
"Cannot get max sleep from " + s);
}
else if(s.startsWith("firstUrl=")) {
firstUrl = s.substring("firstUrl=".length());
if(firstUrl.equals("")) firstUrl = null;
}
else {
urls.add(s);
}
}
 
if(urls.isEmpty()) {
log.error("Need at least one URL to work");
return false;
}
 
return true;
}
catch(Exception ex) {
return false;
}
}
 
private void run()
throws Exception
{
log.info("start " + threadNumber + "/" + requestNumber + "/" + requestPerConnection
+ " " + sleepMin + "/" + sleepMax);
log.info(" firstUrl: " + (firstUrl == null ? "<null>" : firstUrl));
for(int i = 0; i < urls.size(); i++)
log.info(" url: " + urls.get(i));
 
List threads = new ArrayList();
List workers = new ArrayList();
String[] urlArray = (String[])urls.toArray(new String[] {});
 
for(int i = 0; i < threadNumber; i++) {
log.debug("create thread " + i);
HttpThread ht = new HttpThread(firstUrl, urlArray);
workers.add(ht);
ht.setRequestNumber(requestNumber);
ht.setRequestPerConnection(requestPerConnection);
ht.setSleepMin(sleepMin);
ht.setSleepMax(sleepMax);
ht.setTimeout(timeout);
 
Thread t = new Thread(ht);
threads.add(t);
t.start();
}
 
// wait for all
for(int i = 0; i < threads.size(); i++) {
log.debug("wait for thread " + i);
 
Thread t = (Thread)threads.get(i);
try {
t.join();
}
catch(InterruptedException ex) {
}
}
 
// statistics
long totalTime = 0;
long reqTime = 0;
long minTime = Long.MAX_VALUE;
long maxTime = -1;
int successRequest = 0;
int failRequest = 0;
for(int i = 0; i < workers.size(); i++) {
HttpThread ht = (HttpThread)workers.get(i);
if(ht.getSuccess()) {
totalTime += ht.getRunTime();
 
List results = ht.getResults();
for(int j = 0; j < results.size(); j++) {
RequestResult r = (RequestResult)results.get(j);
totalTime -= r.sleepBefore;
if(r.success) {
successRequest++;
 
long t = r.stopTime - r.startTime;
reqTime += t;
if(minTime > t) minTime = t;
if(maxTime < t) maxTime = t;
}
else {
failRequest++;
}
}
}
}
 
log.info("done " + totalTime + "ms / " + successRequest + " = "
+ (totalTime / successRequest) + "ms "
+ minTime + "/" + (reqTime / successRequest) + "/" + maxTime
+ " ms, " + failRequest + " failed");
}
}
 
class HttpThread
class RequestResult
{
public boolean success = false;
public String url;
public long sleepBefore;
public long startTime;
public long stopTime;
public int code;
public Exception exception;
}
 
class HttpThread implements Runnable
{
private static int threadCount = 0;
private static Log log = LogFactory.getLog(HttpThread.class);
 
28,7 → 198,12
private int requestPerConnection = 0; // 0 == all
private int sleepMin = 0;
private int sleepMax = 0;
private int timeout = 0;
 
private boolean success;
private long runTime;
private List results;
 
public HttpThread(String firstUrl, String[] urls)
{
id = threadCount++;
61,11 → 236,6
this.requestPerConnection = requestPerConnection;
}
 
public int getSleepMin()
{
return sleepMin;
}
 
public void setSleepMin(int sleepMin)
{
this.sleepMin = sleepMin;
81,38 → 251,85
this.sleepMax = sleepMax;
}
 
public int getTimeout()
{
return timeout;
}
 
public void setTimeout(int timeout)
{
this.timeout = timeout;
}
 
public boolean getSuccess()
{
return success;
}
 
public long getRunTime()
{
return runTime;
}
 
public List getResults()
{
return results;
}
 
public void run()
{
long startTime = 0;
long stopTime = 0;
long sumSleep = 0;
 
long sumSleep = 0;
log.info(Integer.toString(id) + ": start");
 
try {
HttpClient client = new HttpClient();
 
startTime = System.currentTimeMillis();
results = new ArrayList();
for(int i = 0; i < requestNumber; i++) {
String url;
results.add(new RequestResult());
}
 
long startTime = System.currentTimeMillis();
for(int i = 0; i < requestNumber; i++) {
RequestResult result = (RequestResult)results.get(i);
 
if(sleepMax > 0) {
long sleep = (long)(Math.random() * (sleepMax - sleepMin)) + sleepMin;
sumSleep += sleep;
result.sleepBefore = sleep;
log.trace(Integer.toString(id) + ": sleep for " + sleep + "ms");
Thread.sleep(sleep);
}
 
if(i == 0 && firstUrl != null)
url = firstUrl;
result.url = firstUrl;
else
url = urls[(firstUrl == null ? i : i-1) % urls.length];
result.url = urls[(firstUrl == null ? i : i-1) % urls.length];
 
GetMethod get = new GetMethod(url);
GetMethod get = new GetMethod(result.url);
get.getParams().setSoTimeout(timeout);
 
try {
int result = client.executeMethod(get);
result.startTime = System.currentTimeMillis();
result.code = client.executeMethod(get);
result.stopTime = System.currentTimeMillis();
result.success = true;
 
if(log.isTraceEnabled()) {
String response = get.getResponseBodyAsString();
log.trace(Integer.toString(id) + ": got " + result + "\n'"
+ response.substring(0, 100) + "'");
log.trace(Integer.toString(id) + ": got " + result
+ " in " + (result.stopTime - result.startTime)
+ "ms \n'" + response.substring(0, 100) + "'");
}
else if(log.isDebugEnabled()) {
log.debug(Integer.toString(id) + ": got " + result);
log.debug(Integer.toString(id) + ": got " + result
+ " in " + (result.stopTime - result.startTime) + "ms");
}
}
catch(Exception ex) {
result.stopTime = System.currentTimeMillis();
result.exception = ex;
}
finally {
get.releaseConnection();
}
124,24 → 341,19
+ ": request per connection limit reached at " + i);
client.getHttpConnectionManager().closeIdleConnections(0);
}
 
if(sleepMax > 0 && i < requestNumber-1) {
long sleep = (long)(Math.random() * (sleepMax - sleepMin)) + sleepMin;
log.debug(Integer.toString(id) + ": sleep for " + sleep + "ms");
Thread.currentThread().sleep(sleep);
sumSleep += sleep;
}
}
 
client.getHttpConnectionManager().closeIdleConnections(0);
stopTime = System.currentTimeMillis();
success = true;
runTime = System.currentTimeMillis() - startTime;
}
catch(Exception ex) {
success = false;
log.warn(Integer.toString(id), ex);
}
 
log.info(Integer.toString(id) + ": done" + (stopTime > 0 ? " in " + (stopTime - startTime)
+ "ms, sleeped for " + sumSleep + " ms" : ""));
log.info(Integer.toString(id) + ": done" + (success ? " " + runTime
+ "/" + sumSleep + "/" + (runTime - sumSleep) + " ms": " with error"));
}
}
 
/httpbench/trunk/build.xml
40,9 → 40,31
<target name="run" depends="compile">
<java classname="ak.httpbench.HttpBench" fork="yes">
<classpath refid="run.classpath" />
<arg value="thr=5" />
<arg value="req=8" />
<arg value="rpc=0" />
<arg value="sleepMin=0" />
<arg value="sleepMax=100" />
<arg value="timeout=60000" />
<arg value="firstUrl=" />
<arg value="http://sun" />
</java>
</target>
 
<target name="fullrun" depends="compile">
<java classname="ak.httpbench.HttpBench" fork="yes">
<classpath refid="run.classpath" />
<arg value="thr=100" />
<arg value="req=100" />
<arg value="rpc=5" />
<arg value="sleepMin=1000" />
<arg value="sleepMax=10000" />
<arg value="timeout=60000" />
<arg value="firstUrl=" />
<arg value="http://sun" />
</java>
</target>
 
<target name="all" depends="clean,compile" />
 
</project>