[软件测试]网站压测工具Webbench源码分析

int Socket(const char *host, int clientPort)
{
    //以host为服务器端ip，clientPort为服务器端口号建立socket连接
    //连接类型为TCP，使用IPv4网域
    //一旦出错，返回-1
    //正常连接，则返回socket描述符
}

static void alarm_handler(int signal); //为方便下文引用，我们称之为函数1。
static void usage(void); //函数2
void build_request(const char *url); //函数3
static int bench(void); //函数4
void benchcore(const char *host, const int port, const char *req); //函数5
int main(int argc, char *argv[]); //函数6

volatile int timerexpired=0;//判断压测时长是否已经到达设定的时间
int speed=0; //记录进程成功得到服务器响应的数量
int failed=0;//记录失败的数量（speed表示成功数，failed表示失败数）
int bytes=0;//记录进程成功读取的字节数
int http10=1;//http版本，0表示http0.9，1表示http1.0，2表示http1.1
int method=METHOD_GET; //默认请求方式为GET，也支持HEAD、OPTIONS、TRACE
int clients=1;//并发数目，默认只有1个进程发请求，通过-c参数设置
int force=0;//是否需要等待读取从server返回的数据，0表示要等待读取
int force_reload=0;//是否使用缓存，1表示不缓存，0表示可以缓存页面
int proxyport=80; //代理服务器的端口
char *proxyhost=NULL; //代理服务器的ip
int benchtime=30; //压测时间，默认30秒，通过-t参数设置
int mypipe[2]; //使用管道进行父进程和子进程的通信
char host[MAXHOSTNAMELEN]; //服务器端ip
char request[REQUEST_SIZE]; //所要发送的http请求

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"
    );
};

GET /test.jpg HTTP/1.1
User-Agent: WebBench 1.5
Host:192.168.10.1
Pragma: no-cache
Connection: close

int main(int argc, char *argv[])
{
    /*函数最开始，使用getopt_long函数读取命令行参数，
    来设置（1）中所提及的全局变量的值。
    关于getopt_long的具体使用方法，这里有一个配有讲解的小例子，可以帮助学习：
    http://blog.csdn.net/lanyan822/article/details/7692013
    在此期间如果出现错误，会调用函数2告知用户此工具使用方法，然后退出。
    */
    
    build_request(argv[optind]); //参数读完后，argv[optind]即放在命令行最后的url
                              //调用函数3建立完整的HTTP request，
                            //HTTP request存储在全部变量char request[REQUEST_SIZE]
    
    /*接下来的部分，main函数的所有代码都是在网屏幕上打印此次测试的信息，
    例如即将测试多少秒，几个并发进程，使用哪个HTTP版本等。
    这些信息并非程序核心代码，因此我们也略去。
    */
    
    return bench(); //简简单单一句话，原来，压力测试在这最后一句才真正开始！
                 //所有的压测都在bench函数（即函数4）实现
}

static int bench(void){
  int i,j,k;    
  pid_t pid=0;
  FILE *f;
  
  i=Socket(proxyhost==NULL?host:proxyhost,proxyport); //调用了Socket.c文件中的函数
  if(i<0){ /*错误处理*/ }
  close(i);

  if(pipe(mypipe)){ /*错误处理*/ } //管道用于子进程向父进程回报数据
  for(i=0;i<clients;i++){//根据clients大小fork出来足够的子进程进行测试
       pid=fork();
       if(pid <= (pid_t) 0){
           sleep(1); /* make childs faster */
           break;
       }
  }
  if( pid< (pid_t) 0){ /*错误处理*/ }

  if(pid== (pid_t) 0){//如果是子进程，调用benchcore进行测试
    if(proxyhost==NULL)
      benchcore(host,proxyport,request);
    else
      benchcore(proxyhost,proxyport,request);

     f=fdopen(mypipe[1],"w");//子进程将测试结果输出到管道
     if(f==NULL){ /*错误处理*/ }
     fprintf(f,"%d %d %d\n",speed,failed,bytes);
     fclose(f);
     return 0;
  } else{//如果是父进程，则从管道读取子进程输出，并作汇总
     f=fdopen(mypipe[0],"r");
      if(f==NULL) { /*错误处理*/ }
      setvbuf(f,NULL,_IONBF,0);
      speed=0;  failed=0;  bytes=0;

      while(1){ //从管道读取数据，fscanf为阻塞式函数
          pid=fscanf(f,"%d %d %d",&i,&j,&k);
          if(pid<2){ /*错误处理*/ }
          speed+=i;  failed+=j;  bytes+=k;
          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;

 sa.sa_handler=alarm_handler; //设置函数1为信号处理函数
 sa.sa_flags=0;
 if(sigaction(SIGALRM,&sa,NULL)) //超时会产生信号SIGALRM，用sa中的指定函数处理
    exit(3); 
 
 alarm(benchtime);//开始计时
 rlen=strlen(req);
 nexttry:while(1){
    if(timerexpired){//一旦超时则返回
       if(failed>0){failed--;}
       return;
    }
    s=Socket(host,port);//调用Socket函数建立TCP连接
    if(s<0) { failed++;continue;} 
    if(rlen!=write(s,req,rlen)) {failed++;close(s);continue;} //发出请求
      if(http10==0) //针对http0.9做的特殊处理
        if(shutdown(s,1)) { failed++;close(s);continue;}
    
    if(force==0){//全局变量force表示是否要等待服务器返回的数据
        while(1){
        if(timerexpired) break;
          i=read(s,buf,1500);//从socket读取返回数据
          if(i<0) { 
          failed++;
          close(s);
          goto nexttry;
        }else{
          if(i==0) break;
            else
              bytes+=i;
        }
        }
    }
    if(close(s)) {failed++;continue;}
    speed++;
 }
}