前言

Apache
Bench是1个总结易用的下压力测试工具,在那边本人不想多讲。前几天重点说的是写2个py脚本来自动化测试进程,以及中等蒙受的有的奇葩难题。

测试脚本

#!/usr/bin/env python
# encoding: utf-8
import sys
import subprocess as sub
import json
import re
import time
store=open(sys.argv[1],'w')
if len(sys.argv)>2:
    total=sys.agrv[2]
else:
    total=10000
if len(sys.argv)>3:
    hostPath=sys.argv[3]
else:
    hostPath='http://127.0.0.1:3000/'
#url=['index','str','json','read','write','chain']
#cocurrency=[8,16,32,64,128,256]
url=['str','json','chain'];cocurrency=[16]
result=dict.fromkeys(url,{})
def parseAB(src,dst):
    src=src.split('\n')
    pattern=re.compile(r'\d+\.{0,1}\d{0,10}')
    for i in range(15,len(src)-10):
        if(src[i].count(':')==0):
            continue
        tmp=src[i].split(':')
        key=tmp[0]
        data=pattern.findall(tmp[1])
        if not data:
            continue
        elif(len(data)>1):
            dst[key]=[]
            for j in data:
                dst[key]=dst[key]+[float(j)]
        else:
            dst[key]=float(data[0])
        dst['percentage']={}
    for i in range(len(src)-10,len(src)):
        tmp=pattern.findall(src[i])
        if(len(tmp)!=2):
            continue
        dst['percentage'][int(tmp[0])]=int(tmp[1])
    return dst

for item in url:
    for c in cocurrency:
        child=sub.check_output('ab -k -n '+str(total)+' -c '+str(c)+' '+hostPath+item,shell=True,close_fds=True)
        #child=sub.Popen('ab -k -n '+str(total)+' -c '+str(c)+' '+hostPath+item,shell=True,close_fds=True,stdout=sub.PIPE)
        result[item][c]={}
        parseAB(child,result[item][c])
        time.sleep(5)

store.write(json.dumps(result));
store.close()

最终赢得了二个饱含该框架全体测试音讯的json文件,之所以选用json那种数据格式,是为着便于下一步处理。

分析脚本

#!/usr/bin/env python
# encoding: utf-8

import sys
import json

basePath=''
frame=['express']
data={}

for f in frame:
    data[f]=json.loads(open(basePath+f+'.json','r').read())
url=data[frame[0]].keys()
cocurrency=data[frame[0]][url[0]].keys()
keyList=data[frame[0]][url[0]][cocurrency[0]].keys()
print 'you can get these key:   '+str(keyList)
compare=dict.fromkeys(frame,dict.fromkeys(url,{}))
for f in frame:
    for u in url:
        for k in keyList:
            dataType=type(data[f][u][cocurrency[0]][k])
            if dataType==int or dataType==float:
                tmp=[]
                for c in cocurrency:
                    tmp=tmp+[dataType(data[f][u][c][k])]
                compare[f][u][k]=tmp
            elif dataType==dict:
                percent=data[f][u][cocurrency[0]][k].keys()
                tmp=dict.fromkeys(percent,[])
                for p in percent:
                    for c in cocurrency:
                        tmp[p]=tmp[p]+[data[f][u][c][k][p]]
                compare[f][u][k]=tmp
            elif dataType==list:
                sta=['min','mean','sd','median','max']
                tmp=dict.fromkeys(sta,[])
                for i in range(len(sta)):
                    for c in cocurrency:
                        s=sta[i]
                        tmp[s]=tmp[s]+[data[f][u][c][k][i]]
                compare[f][u][k]=tmp

def get(f,u,k,index=None):
    if k=='percentage':
        if not index:
            return compare[f][u][k]['95']
        else:
            return compare[f][u][k][str(index)]
    elif type(compare[f][u][k])==dict:
        if not index:
            return compare[f][u][k]['mean']
        else:
            return compare[f][u][k][index]
    else:
        return compare[f][u][k]

最终暴暴光三个API接口

import handle
handle.get('express','json','Time per request')
//return an array for all cocurrency you choose

欣逢的题材

在测试进度中(开始的本子不是其一样子的,有稍许的转移)到1四千+请求的时候会卡主,并最终抛出socket
timeout的不当,错误码60.为何会这规范呢?

是出于系统能源的限制,socket在unix系统下也是采纳文件讲述符的,socket的多少是有限制的,对于自己的MAC是16387,据他们说对于linux系统是33000+,好,找到了问题所在,看来是子进度退出时没有关闭socket。在python的bug报告里提到了那几个题目,在subprocess的调用中加一句close_fds=True能够在子进度执行在此以前关闭除了0,1,2的保有文件描述符,自然就关门了上次操作的全体sockets。

可是,那样依旧至极。。。为何吧?因为不用忘了服务器是localhost,关闭那么些文件讲述符只是客户端的socket.close(),意味着文件讲述符能够被重新分配,但服务端依旧拥有socket,它的财富没有被释放,限制依旧存在。想要立时放飞,大家应该用socket.shutdown(),也才那样恐怕必要改写subprocess,显著蛋疼。

然后本人就意识了自小编的测试语句

ab -c 8 -n 10000 http://127.0.0.1:3000/json

对,木有用-k,keep-alive选项允许socket被复用,不只是用来二个http请求。同时小编还在循环末尾加了一句sleep以等待能源被放走。剩下的就只可以坐以待毙了。

再有2个百般广泛的荒唐。

ab -c 8 -n 10000 http://localhost:3000/json

写成这样也会报错哦!

结语

最后向我们提叁个难题,为何用Jmeter做压力测试的时候,吞吐量会一初步很高,然后直接在下跌?

相关文章

网站地图xml地图