def main():
(opts, _) = optionParser.parseCommandLine()
tunnelTargetPort = opts.dbPort
tunnelTargetHost = opts.dbHost
opts.dbPort = opts.tunnelPort
opts.dbHost = 'localhost'
runner.startTunnel(opts, processes, tunnelTargetHost, tunnelTargetPort)
runner.startBackend(opts, processes)
runner.startHttpd(opts, processes)
runner.setBackendTime(processes, "2014-03-21 18:12:00")
# we have to create connection here to be reused
print 'connecting to db on localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:'+opts.httpdPort)
issueRequest(connection, opts.userId, "http://www.onet.pl", runner.INTERNET_ACCESS_FORBIDDEN)
runner.stopTunnel(processes)
issueRequest(connection, opts.userId, "http://www.onet.pl", runner.ACCESS_OK)
runner.startTunnel(opts, processes, tunnelTargetHost, tunnelTargetPort)
issueRequest(connection, opts.userId, "http://www.onet.pl", runner.INTERNET_ACCESS_FORBIDDEN)
print "All tests OK"
def main():
(opts, _) = optionParser.parseCommandLine()
realWebrootPort = 80
realWebrootHost = 'service2.brightcloud.com'
webrootCfgPath = 'scripts/tests/webrootUnavailableTest/webroot.cfg'
fp = open(webrootCfgPath)
for i, line in enumerate(fp):
if 'BcapPort' in line:
opts.tunnelPort = getValueFromConfigLine(line)
if 'BcapServer' in line:
tunnelHost = getValueFromConfigLine(line)
fp.close()
connectionMax = str(NUM_OF_THREADS * 3 + 100)
httpdArgs = [
"--connectionPerIpLimitAbsolute",
connectionMax,
"--connectionPerIpLimitSlowDown",
connectionMax,
]
opts.webrootConfigFilePath = os.path.join(runner.getRepoDir(),
webrootCfgPath)
runner.startTunnel(opts, processes, tunnelHost, realWebrootPort,
realWebrootHost)
runner.startBackend(opts, processes)
runner.startHttpd(opts, processes, httpdArgs)
runner.setBackendTime(processes, "2014-03-21 16:12:00")
# we have to create connection here to be reused
#print 'connecting to db on localhost:%s' % opts.httpdPort
connection = runner.createConnection('localhost:' + opts.httpdPort)
issueRequest(connection, opts.userId, "http://www.takatamstronahehe.pl",
runner.ACCESS_OK, False)
issueRequest(connection, opts.userId, "http://pornhub.com",
runner.CATEGORY_BLOCKED_CUSTOM, False)
issueRequest(connection, opts.userId, "http://www.onet.pl",
runner.ACCESS_OK, False)
runner.stopTunnel(processes)
server_address = (tunnelHost, int(opts.tunnelPort))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(server_address)
sock.listen(1)
for i in range(0, NUM_OF_THREADS):
newThread = multiprocessing.Process(target=sendFewRequest,
args=(opts, ))
newThread.start()
threads.append(newThread)
time.sleep(10)
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 sendFewRequest(opts):
connection = runner.createConnection('localhost:' + opts.httpdPort)
issueRequest(connection,
opts.userId,
"http://www.innasmiesznastrona.pl",
runner.ACCESS_OK,
timeoutExpected=None)
issueRequest(connection, opts.userId, "http://pornhub.com",
runner.CATEGORY_BLOCKED_CUSTOM, False)
issueRequest(connection, opts.userId, "http://www.onet.pl",
runner.ACCESS_OK, False)
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 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)
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 createConnection(opts):
return runner.createConnection(opts.httpdHost + ":" + opts.httpdPort,
isHttps=True)