def issueRequest(connection, userId, url, expectedResult):
url = url.strip()
print 'requesting url:', url
runner.sendRequest(connection, url, userId)
headers = runner.readResponse(connection, expectedHeaders = {'result': expectedResult})
print 'Result:', headers['result']
print 'all headers:\n', headers
def issueRequest(opts, url, expectedResult):
print 'connecting to localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:' + opts.httpdPort)
url = url.strip()
print 'requesting url:', url
runner.sendRequest(connection, url, opts.userId)
headers = runner.readResponse(connection, expectedHeaders = {'result': expectedResult})
print 'Result:', headers['result']
print 'all headers:\n', headers
def issueSslRequest(opts, url, timeout):
print 'connecting to localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:' + opts.httpdPort,
isHttps=True)
url = url.strip()
print 'requesting url:', url
runner.sendRequest(connection, url, opts.userId)
headers = runner.readResponse(connection, timeoutExpected=timeout)
print 'Result:', headers['result']
print 'all headers:\n', headers
def issueRequests(opts, urls, idx):
global tats
global sumTat
global numRequests
global delay
print idx, 'connecting to %s:%s' % (opts.httpdHost, opts.httpdPort)
connection = createConnection(opts)
lastTick = time.time()
urlIdx = random.randint(1, 1000) # each client starts from random url
while True:
if urlIdx == len(urls):
urlIdx = 0
nextTick = lastTick + INTERVAL_MS / 1000.0
if time.time() > nextTick:
delay = time.time() - nextTick
while time.time() < nextTick:
time.sleep(INTERVAL_MS / 1000.0 /
10) # sleep 1/10th of INTERVAL_MS
currentTick = nextTick
url = urls[urlIdx]
url = url.strip()
userId = random.randint(
generateProfileData.BASE_ID,
generateProfileData.BASE_ID + generateProfileData.NUM_PROFILES)
#userId = 70514
#print 'requesting url:', url
currentTime = time.time()
runner.sendRequest(connection, url, userId)
try:
headers = runner.readResponse(connection, timeoutExpected=None)
except:
print 'Got exception reading response; connection closed?'
connection.close()
connection = createConnection(opts)
headers = {'result': 'FAILED'}
duration = time.time() - currentTime
if headers['result'] != '0' and False:
print currentTime, 'BLOCKED!', url, headers
tats.append(duration)
sumTat += duration
numRequests += 1
urlIdx += 1
lastTick = currentTick
print "total requests duration: %.2f" % duration
return duration
def issueRequests(opts, urls):
print 'connecting to localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:' + opts.httpdPort)
startTime = time.time()
for url in urls:
url = url.strip()
print 'requesting url:', url
runner.sendRequest(connection, url, opts.userId)
runner.readResponse(connection,
expectedHeaders={'result': runner.ACCESS_OK})
return time.time() - startTime
def issueRequest(opts,
url,
expectedResult,
expectedHttpStatus=200,
userId=None,
headerResult=runner.ACCESS_OK,
addHeaders={}):
connection = runner.createConnection('localhost:' + opts.httpdPort)
url = url.strip()
if userId is None:
userId = opts.userId
runner.sendRequest(connection, url, userId, addHeaders=addHeaders)
runner.readResponse(connection,
expectedHeaders={'result': headerResult},
expectedHttpStatus=expectedHttpStatus)
def startConcurrentRequests(opts, urls):
print 'connecting to localhost:%s' % opts.httpdPort
pool = []
for _ in xrange(len(urls)):
pool.append(runner.createConnection('localhost:' + opts.httpdPort))
for idx in xrange(len(urls)):
url = urls[idx]
url = url.strip()
print 'requesting url:', url
connection = pool[idx]
runner.sendRequest(connection, url, opts.userId)
return pool
def issueSequentialRequests(opts, urls, timeoutExpected=False):
print 'connecting to localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:' + opts.httpdPort)
for url in urls:
url = url.strip()
print 'requesting url:', url
startTime = time.time()
runner.sendRequest(connection, url, opts.userId)
headers = runner.readResponse(connection,
timeoutExpected=timeoutExpected)
duration = time.time() - startTime
print 'Result:', headers['result']
print 'all headers:\n', headers
print 'duration: %.2f' % duration
def issueRequests(opts, urls, idx):
print 'connecting to %s:%s' % (opts.httpdHost, opts.httpdPort)
connection = runner.createConnection(opts.httpdHost + ":" + opts.httpdPort)
startTime = time.time()
for url in urls:
url = url.strip()
#print 'requesting url:', url
runner.sendRequest(connection, url, opts.userId)
headers = runner.readResponse(connection)
#print 'Result:', headers['result']
#print 'duration: %.2f' % duration
duration = time.time() - startTime
print "total requests duration: %.2f" % duration
return duration
def issueConcurrentRequests(opts, requests):
print 'connecting to localhost:%s' % opts.httpdPort
pool = []
for _ in xrange(len(requests)):
pool.append(runner.createConnection('localhost:' + opts.httpdPort))
for idx in xrange(len(requests)):
connection = pool[idx]
request = requests[idx]
print 'requesting url:', request.url
runner.sendRequest(connection,
request.url,
request.userId,
userAction=request.userAction,
quote=request.quote)
for idx in xrange(len(requests)):
connection = pool[idx]
request = requests[idx]
expectedHeaders = dict()
if request.expectedResult is not None:
expectedHeaders['result'] = request.expectedResult
if request.categoryGroupId is not None and (
# SAF-382
request.expectedResult != runner.ACCESS_OK
or request.userAction == UserActionCode.CATEGORY_GROUP_QUERY):
expectedHeaders['category-group-id'] = request.categoryGroupId
print 'Request:', request.url
if not isValidUserAction(request.userAction):
print 'Sent invalid UserAction (%s), expecting HTTP 400' % (
request.userAction, )
runner.readResponse(connection, expectedHttpStatus=400)
else:
headers = runner.readResponse(connection, expectedHeaders)
print 'Result:', headers['result']
print 'all headers:\n', headers
if request.expectedResult is None:
request.expectedResult = headers['result']
if request.categoryGroupId is None and 'category-group-id' in headers:
request.categoryGroupId = headers['category-group-id']
def main():
(opts, _) = optionParser.parseCommandLine()
runner.startHttpd(opts, processes)
connection = runner.createConnection('localhost:' + opts.httpdPort)
time.sleep(CLIENT_TIMEOUT - 6)
# this should be ok, no timeout yet (possible timeout on backend/database)
runner.sendRequest(connection, 'onet.pl', opts.userId)
runner.readResponse(connection, {}, True)
time.sleep(CLIENT_TIMEOUT + 3)
# this should fail with connection closed (HttpException)
runner.sendRequest(connection, 'onet.pl', opts.userId)
try:
runner.readResponse(connection)
print "connection should be closed by server"
sys.exit(-1)
except HTTPException:
pass
def issueRequestsCommon(host, urls, userId, shouldStopFunc):
connection = runner.createConnection(host)
startTime = time.time()
numTimeouts = 0
firstIteration = True
numConsecutiveFailures = 0
while shouldStopFunc is not None or firstIteration:
if shouldStopFunc is not None and shouldStopFunc():
break
for url in urls:
if shouldStopFunc is not None and shouldStopFunc():
break
url = url.strip()
try:
connectionOk = False
runner.sendRequest(connection, url, userId)
headers = runner.readResponse(connection, expectedHeaders = {}, timeoutExpected = None)
if runner.isTimeout(headers):
numTimeouts += 1
assert headers['result'] != runner.UNKNOWN_USER, "please use existing userId as otherwise performance is meaningless"
connectionOk = True
except httplib.BadStatusLine:
print "Warning: bad status line for: %s" % url
except httplib.CannotSendRequest:
print "Warning: cannot send request for: %s" % url
if connectionOk:
numConsecutiveFailures = 0
else:
numConsecutiveFailures += 1
assert numConsecutiveFailures < 2, "too many consecutive failures, webservice is probably down"
print "Warning: connection lost, reconnecting"
connection.close()
connection = runner.createConnection(host)
firstIteration = False
duration = time.time() - startTime
return (duration, numTimeouts)
