Webbench

简介

Webench是一款轻量级的网站测压工具，最多可以对网站模拟3w左右的并发请求，可以控制时间、是否使用缓存、是否等待服务器回复等等，且对中小型网站有明显的效果，基本上可以测出中小型网站的承受能力，对于大型的网站，如百度、淘宝这些巨型网站没有意义，因为其承受能力非常大。同时测试结果也受自身网速、以及自身主机的性能与内存的限制，性能好、内存大的主机可以模拟的并发就明显要多。
Webbench能测试处在相同硬件上，不同服务的性能以及不同硬件上同一个服务的运行状况。webbench的标准测试可以向我们展示服务器的两项内容：每秒钟相应请求数和每秒钟传输数据量。webbench不但具有静态页面的测试能力，还能对动态页面（ASP,PHP,JAVA,CGI）进行测试的能力。还有就是他支持对含有SSL的安全网站例如电子商务网站进行静态或动态的性能测试。

安装

github：地址
下载压缩文件 webbench-1.5.tar.gz
解压，编译，在当前目录生成webbench可执行文件

用法

通过帮助信息了解

webbench [option]... URL
  -f|--force               Don't wait for reply from server.
  -r|--reload              Send reload request - Pragma: no-cache.
  -t|--time <sec>          Run benchmark for <sec> seconds. Default 30.
  -p|--proxy <server:port> Use proxy server for request.
  -c|--clients <n>         Run <n> HTTP clients at once. Default one.
  -9|--http09              Use HTTP/0.9 style requests.
  -1|--http10              Use HTTP/1.0 protocol.
  -2|--http11              Use HTTP/1.1 protocol.
  --get                    Use GET request method.
  --head                   Use HEAD request method.
  --options                Use OPTIONS request method.
  --trace                  Use TRACE request method.
  -?|-h|--help             This information.
  -V|--version             Display program version.

示例

通过访问http://www.baidu.com/来测试

1个客户端，持续60s

$./webbench -c 1 -t 60 http://www.baidu.com/
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.

Benchmarking: GET http://www.baidu.com/
1 client, running 60 sec.

Speed=183 pages/min, 873009 bytes/sec.
Requests: 183 susceed, 0 failed.

100个客户端，持续30s

$./webbench -c 100 -t 30 http://www.baidu.com/
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.

Benchmarking: GET http://www.baidu.com/
100 clients, running 30 sec.

Speed=162 pages/min, 1106176 bytes/sec.
Requests: 78 susceed, 3 failed.

涉及知识点

命令行解析
进程创建
IPC（管道）
socket

主要函数

main：函数入口，命令行解析
usage：帮助信息
build_request：通信报文创建
bench：进程创建，父进程接收子进程的运行结果
benchcore：通信测试
Socket：创建tcp连接
alarm_handler：定时处理

主要流程

注释源码

socket.c

int Socket(const char *host, int clientPort)
{
    int sock;
    unsigned long inaddr;
    struct sockaddr_in ad;
    struct hostent *hp;
    
    memset(&ad, 0, sizeof(ad));
    ad.sin_family = AF_INET;

	/* ip或域名赋值 */
    inaddr = inet_addr(host);
    if (inaddr != INADDR_NONE)
        memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));
    else
    {
        hp = gethostbyname(host);
        if (hp == NULL)
            return -1;
        memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
    }
    /* 端口号赋值 */
    ad.sin_port = htons(clientPort);
    
    /* 创建套接字 */
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0)
        return sock;
    
    /* 连接指定ip或域名 */
    if (connect(sock, (struct sockaddr *)&ad, sizeof(ad)) < 0)
        return -1;
    
    /* 返回套接字 */
    return sock;
}

webbench.c

static void alarm_handler(int signal)
{
	/* 定时处理 */
	timerexpired=1;
}	

static void usage(void)
{
	/* 帮助信息 */
	fprintf(stderr,
			"webbench [option]... URL\n"
			"  -f|--force               Don't wait for reply from server.\n"
			"  -r|--reload              Send reload request - Pragma: no-cache.\n"
			"  -t|--time <sec>          Run benchmark for <sec> seconds. Default 30.\n"
			"  -p|--proxy <server:port> Use proxy server for request.\n"
			"  -c|--clients <n>         Run <n> HTTP clients at once. Default one.\n"
			"  -9|--http09              Use HTTP/0.9 style requests.\n"
			"  -1|--http10              Use HTTP/1.0 protocol.\n"
			"  -2|--http11              Use HTTP/1.1 protocol.\n"
			"  --get                    Use GET request method.\n"
			"  --head                   Use HEAD request method.\n"
			"  --options                Use OPTIONS request method.\n"
			"  --trace                  Use TRACE request method.\n"
			"  -?|-h|--help             This information.\n"
			"  -V|--version             Display program version.\n"
	       );
};
int main(int argc, char *argv[])
{
	int opt=0;
	int options_index=0;
	char *tmp=NULL;

	if(argc==1)
	{
		usage();
		return 2;
	} 

	/* 长命令行解析 */
	while((opt=getopt_long(argc,argv,"912Vfrt:p:c:?h",long_options,&options_index))!=EOF )
	{
		switch(opt)
		{
			case  0 : break;
			case 'f': force=1;break;
			case 'r': force_reload=1;break; 
			case '9': http10=0;break;
			case '1': http10=1;break;
			case '2': http10=2;break;
			case 'V': printf(PROGRAM_VERSION"\n");exit(0);
			case 't': benchtime=atoi(optarg);break;	     
			case 'p': 
				  /* proxy server parsing server:port */
				  tmp=strrchr(optarg,':');
				  proxyhost=optarg;
				  if(tmp==NULL)
				  {
					  break;
				  }
				  if(tmp==optarg)
				  {
					  fprintf(stderr,"Error in option --proxy %s: Missing hostname.\n",optarg);
					  return 2;
				  }
				  if(tmp==optarg+strlen(optarg)-1)
				  {
					  fprintf(stderr,"Error in option --proxy %s Port number is missing.\n",optarg);
					  return 2;
				  }
				  *tmp='\0';
				  proxyport=atoi(tmp+1);break;
			case ':':
			case 'h':
			case '?': usage();return 2;break;
			case 'c': clients=atoi(optarg);break;
		}
	}

	/* 判断是否存在URL */
	if(optind==argc) {
		fprintf(stderr,"webbench: Missing URL!\n");
		usage();
		return 2;
	}

	/* 客户端和持续时间默认值处理 */
	if(clients==0) clients=1;
	if(benchtime==0) benchtime=60;
	/* Copyright */
	fprintf(stderr,"Webbench - Simple Web Benchmark "PROGRAM_VERSION"\n"
			"Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.\n"
	       );
	/* 构建请求报文 */
	build_request(argv[optind]);
	/* print bench info */
	printf("\nBenchmarking: ");
	switch(method)
	{
		case METHOD_GET:
		default:
			printf("GET");break;
		case METHOD_OPTIONS:
			printf("OPTIONS");break;
		case METHOD_HEAD:
			printf("HEAD");break;
		case METHOD_TRACE:
			printf("TRACE");break;
	}
	printf(" %s",argv[optind]);
	switch(http10)
	{
		case 0: printf(" (using HTTP/0.9)");break;
		case 2: printf(" (using HTTP/1.1)");break;
	}
	printf("\n");
	if(clients==1) printf("1 client");
	else
		printf("%d clients",clients);

	printf(", running %d sec", benchtime);
	if(force) printf(", early socket close");
	if(proxyhost!=NULL) printf(", via proxy server %s:%d",proxyhost,proxyport);
	if(force_reload) printf(", forcing reload");
	printf(".\n");
	return bench();
}

void build_request(const char *url)
{
	char tmp[10];
	int i;

	bzero(host,MAXHOSTNAMELEN);
	bzero(request,REQUEST_SIZE);

	if(force_reload && proxyhost!=NULL && http10<1) http10=1;
	if(method==METHOD_HEAD && http10<1) http10=1;
	if(method==METHOD_OPTIONS && http10<2) http10=2;
	if(method==METHOD_TRACE && http10<2) http10=2;

	switch(method)
	{
		default:
		case METHOD_GET: strcpy(request,"GET");break;
		case METHOD_HEAD: strcpy(request,"HEAD");break;
		case METHOD_OPTIONS: strcpy(request,"OPTIONS");break;
		case METHOD_TRACE: strcpy(request,"TRACE");break;
	}

	strcat(request," ");

	if(NULL==strstr(url,"://"))
	{
		fprintf(stderr, "\n%s: is not a valid URL.\n",url);
		exit(2);
	}
	if(strlen(url)>1500)
	{
		fprintf(stderr,"URL is too long.\n");
		exit(2);
	}
	if(proxyhost==NULL)
		if (0!=strncasecmp("http://",url,7)) 
		{ fprintf(stderr,"\nOnly HTTP protocol is directly supported, set --proxy for others.\n");
			exit(2);
		}
	/* protocol/host delimiter */
	i=strstr(url,"://")-url+3;
	/* printf("%d\n",i); */

	if(strchr(url+i,'/')==NULL) {
		fprintf(stderr,"\nInvalid URL syntax - hostname don't ends with '/'.\n");
		exit(2);
	}
	if(proxyhost==NULL)
	{
		/* get port from hostname */
		if(index(url+i,':')!=NULL &&
				index(url+i,':')<index(url+i,'/'))
		{
			strncpy(host,url+i,strchr(url+i,':')-url-i);
			bzero(tmp,10);
			strncpy(tmp,index(url+i,':')+1,strchr(url+i,'/')-index(url+i,':')-1);
			/* printf("tmp=%s\n",tmp); */
			proxyport=atoi(tmp);
			if(proxyport==0) proxyport=80;
		} else
		{
			strncpy(host,url+i,strcspn(url+i,"/"));
		}
		// printf("Host=%s\n",host);
		strcat(request+strlen(request),url+i+strcspn(url+i,"/"));
	} else
	{
		// printf("ProxyHost=%s\nProxyPort=%d\n",proxyhost,proxyport);
		strcat(request,url);
	}
	if(http10==1)
		strcat(request," HTTP/1.0");
	else if (http10==2)
		strcat(request," HTTP/1.1");
	strcat(request,"\r\n");
	if(http10>0)
		strcat(request,"User-Agent: WebBench "PROGRAM_VERSION"\r\n");
	if(proxyhost==NULL && http10>0)
	{
		strcat(request,"Host: ");
		strcat(request,host);
		strcat(request,"\r\n");
	}
	if(force_reload && proxyhost!=NULL)
	{
		strcat(request,"Pragma: no-cache\r\n");
	}
	if(http10>1)
		strcat(request,"Connection: close\r\n");
	/* add empty line at end */
	if(http10>0) strcat(request,"\r\n"); 
	// printf("Req=%s\n",request);
}

/* vraci system rc error kod */
static int bench(void)
{
	int i,j,k;	
	pid_t pid=0;
	FILE *f;

	/* 测试域名合法性 */
	/* check avaibility of target server */
	i=Socket(proxyhost==NULL?host:proxyhost,proxyport);
	if(i<0) { 
		fprintf(stderr,"\nConnect to server failed. Aborting benchmark.\n");
		return 1;
	}
	close(i);
	/* 创建管道 */
	/* create pipe */
	if(pipe(mypipe))
	{
		perror("pipe failed.");
		return 3;
	}

	/* not needed, since we have alarm() in childrens */
	/* wait 4 next system clock tick */
	/*
	   cas=time(NULL);
	   while(time(NULL)==cas)
	   sched_yield();
	   */

	/* 创建压力测试客户端 */
	/* fork childs */
	for(i=0;i<clients;i++)
	{
		pid=fork();
		if(pid <= (pid_t) 0)
		{
			/* child process or error*/
			sleep(1); /* make childs faster */
			break;
		}
	}

	if( pid< (pid_t) 0)
	{
		fprintf(stderr,"problems forking worker no. %d\n",i);
		perror("fork failed.");
		return 3;
	}

	/* 子进程处理 */
	if(pid== (pid_t) 0)
	{
		/* I am a child */
		if(proxyhost==NULL)
			benchcore(host,proxyport,request);
		else
			benchcore(proxyhost,proxyport,request);

		/* write results to pipe */
		f=fdopen(mypipe[1],"w");
		if(f==NULL)
		{
			perror("open pipe for writing failed.");
			return 3;
		}
		/* fprintf(stderr,"Child - %d %d\n",speed,failed); */
		fprintf(f,"%d %d %d\n",speed,failed,bytes);
		fclose(f);
		return 0;
	} else
	{
		/* 父进程通过管道接收运行结果 */
		f=fdopen(mypipe[0],"r");
		if(f==NULL) 
		{
			perror("open pipe for reading failed.");
			return 3;
		}
		setvbuf(f,NULL,_IONBF,0);
		speed=0;
		failed=0;
		bytes=0;

		while(1)
		{
			pid=fscanf(f,"%d %d %d",&i,&j,&k);
			if(pid<2)
			{
				fprintf(stderr,"Some of our childrens died.\n");
				break;
			}
			speed+=i;
			failed+=j;
			bytes+=k;
			/* fprintf(stderr,"*Knock* %d %d read=%d\n",speed,failed,pid); */
			if(--clients==0) break;
		}
		fclose(f);

		printf("\nSpeed=%d pages/min, %d bytes/sec.\nRequests: %d susceed, %d failed.\n",
				(int)((speed+failed)/(benchtime/60.0f)),
				(int)(bytes/(float)benchtime),
				speed,
				failed);
	}
	return i;
}

void benchcore(const char *host,const int port,const char *req)
{
	int rlen;
	char buf[1500];
	int s,i;
	struct sigaction sa;

	/* 通过信号创建定时 */
	/* setup alarm signal handler */
	sa.sa_handler=alarm_handler;
	sa.sa_flags=0;
	if(sigaction(SIGALRM,&sa,NULL))
		exit(3);
	alarm(benchtime);

	rlen=strlen(req);
nexttry:while(1)
	{
		if(timerexpired)
		{
			if(failed>0)
			{
				/* fprintf(stderr,"Correcting failed by signal\n"); */
				failed--;
			}
			return;
		}
		s=Socket(host,port);                          
		if(s<0) { failed++;continue;} 
		if(rlen!=write(s,req,rlen)) {failed++;close(s);continue;}
		if(http10==0) 
			if(shutdown(s,1)) { failed++;close(s);continue;}
		if(force==0) 
		{
			/* read all available data from socket */
			while(1)
			{
				if(timerexpired) break; 
				i=read(s,buf,1500);
				/* fprintf(stderr,"%d\n",i); */
				if(i<0) 
				{ 
					failed++;
					close(s);
					goto nexttry;
				}
				else
					if(i==0) break;
					else
						bytes+=i;
			}
		}
		if(close(s)) {failed++;continue;}
		speed++;
	}
}

结语

1、该开源方案的代码风格不方便阅读，所以拿到代码，首先调整格式
2、大量使用全局变量，不方便阅读，看上去也很乱，可以使用结构体把相关变量规整
3、进程消耗的资源比较大，所以可以尝试使用线程的方式来优化
4、作者提供了一个非常好的测试网页的思路，有很多方面是值得学习的