def read_ports_from_log(self, timeout=30):
deadline = time.time() + timeout
# -- wait for the log file to appear
while time.time() < deadline:
self.check()
if os.path.isfile(self.logfile_path):
break
else:
time.sleep(0.1)
else:
raise RuntimeError(
"Timed out after %d seconds waiting for the log file to appear at: %s" % (timeout, self.logfile_path)
)
# -- monitor the logfile for the given lines
try:
for logLine in utils.nonblocking_readline(self.logfile_path, self._existing_log_len):
if time.time() > deadline:
raise RuntimeError("Timeout while trying to read ports from log file")
if logLine is None:
# - bail out if we are done, or the process is dead
if self.process is None or self.process.poll() is not None or self.ready:
return
time.sleep(0.05)
continue
# - see if it matches one we are looking for
try:
parsedLine = self.logfilePortRegex.search(logLine)
except Exception as e:
warnings.warn("Got unexpected logLine: %s" % repr(logLine))
if parsedLine:
if parsedLine.group("type") == "intracluster":
self._cluster_port = int(parsedLine.group("port"))
elif parsedLine.group("type") == "client driver":
self._driver_port = int(parsedLine.group("port"))
else:
self._http_port = int(parsedLine.group("port"))
continue
parsedLine = self.logfileServerIDRegex.search(logLine)
if parsedLine:
self._uuid = parsedLine.group("uuid")
parsedLine = self.logfileReadyRegex.search(logLine)
if parsedLine:
self._ready_line = True
self._name = parsedLine.group("name")
self._uuid = parsedLine.group("uuid")
finally:
if self.cluster._hasStartLock is self:
self.cluster._hasStartLock = None
self.cluster._startLock.release()
# -- piggyback on this to setup Resunder blocking
self.update_routing()
def test_get_invalid_page(self):
# - open the log file, iterate through all current lines
logFile = utils.nonblocking_readline(self.cluster[0].logfile_path)
while next(logFile) is not None:
pass
# - make the bad access
try:
fetchResult = urllib2.urlopen(os.path.join(self.baseURL, 'foobar'), timeout=2)
except urllib2.HTTPError as e:
self.assertEqual(e.code, 403, 'Got a non 403 code when requesting bad url /foobar: %s' % str(e.code))
else:
self.fail("Did not raise a 403 error code when requesting a bad url")
# - check that the bad access was recorded
deadline = time.time() + 2
foundIt = False
while time.time() < deadline:
thisEntry = next(logFile)
while thisEntry is not None:
if 'Someone asked for the nonwhitelisted file "/foobar"' in thisEntry:
foundIt = True
break
thisEntry = next(logFile)
if foundIt:
break
time.sleep(0.05)
else:
self.fail("Timed out waiting for the bad access marker to be written to the log")
def read_ports_from_log(self, timeout=30):
deadline = time.time() + timeout
# - wait for the log file to appear
while time.time() < deadline:
#self.check()
if os.path.isfile(self.logfile_path):
break
else:
time.sleep(0.1)
else:
raise RuntimeError("Timed out after %d seconds waiting for the log file to appear at: %s" % (timeout, self.logfile_path))
# - monitor the logfile for the given lines
logLines = utils.nonblocking_readline(self.logfile_path)
while time.time() < deadline:
# - bail out if we have everything
if self.ready:
return
# - get a new line or sleep
logLine = next(logLines)
if logLine is None:
time.sleep(0.05)
self.check()
continue
# - see if it matches one we are looking for
try:
parsedLine = self.logfilePortRegex.search(logLine)
except Exception as e:
warnings.warn('Got unexpected logLine: %s' % repr(logLine))
if parsedLine:
if parsedLine.group('type') == 'intracluster':
self._cluster_port = int(parsedLine.group('port'))
elif parsedLine.group('type') == 'client driver':
self._driver_port = int(parsedLine.group('port'))
else:
self._http_port = int(parsedLine.group('port'))
continue
parsedLine = self.logfileServerIDRegex.search(logLine)
if parsedLine:
self._uuid = parsedLine.group('uuid')
parsedLine = self.logfileReadyRegex.search(logLine)
if parsedLine:
self.ready = True
self._name = parsedLine.group('name')
self._uuid = parsedLine.group('uuid')
else:
raise RuntimeError("Timeout while trying to read cluster port from log file")
def read_ports_from_log(self, timeout=30):
deadline = time.time() + timeout
# -- wait for the log file to appear
while time.time() < deadline:
self.check()
if os.path.isfile(self.logfile_path):
break
else:
time.sleep(0.1)
else:
raise RuntimeError("Timed out after %d seconds waiting for the log file to appear at: %s" % (timeout, self.logfile_path))
# -- monitor the logfile for the given lines
try:
for logLine in utils.nonblocking_readline(self.logfile_path, self._existing_log_len):
if time.time() > deadline:
raise RuntimeError("Timeout while trying to read ports from log file")
if logLine is None:
# - bail out if we are done, or the process is dead
if self.process is None or self.process.poll() is not None or self.ready:
return
time.sleep(0.05)
continue
# - see if it matches one we are looking for
try:
parsedLine = self.logfilePortRegex.search(logLine)
except Exception as e:
warnings.warn('Got unexpected logLine: %s' % repr(logLine))
if parsedLine:
if parsedLine.group('type') == 'intracluster':
self._cluster_port = int(parsedLine.group('port'))
elif parsedLine.group('type') == 'client driver':
self._driver_port = int(parsedLine.group('port'))
else:
self._http_port = int(parsedLine.group('port'))
continue
parsedLine = self.logfileServerIDRegex.search(logLine)
if parsedLine:
self._uuid = parsedLine.group('uuid')
parsedLine = self.logfileReadyRegex.search(logLine)
if parsedLine:
self._ready_line = True
self._name = parsedLine.group('name')
self._uuid = parsedLine.group('uuid')
finally:
if self.cluster._hasStartLock is self:
self.cluster._hasStartLock = None
self.cluster._startLock.release()
# -- piggyback on this to setup Resunder blocking
self.update_routing()
def __init__(self,
httpbinPort=0,
httpPort=0,
sslPort=0,
startupTimeout=20):
'''Start a server, using subprocess to do it out-of-process'''
# -- startup server
runableFile = __file__.rstrip('c')
self.__serverOutput = tempfile.NamedTemporaryFile(mode='w+')
self.__serverProcess = subprocess.Popen([
runableFile, '--httpbin-port',
str(httpbinPort), '--http-port',
str(httpPort), '--ssl-port',
str(sslPort)
],
stdout=self.__serverOutput,
preexec_fn=os.setpgrp)
# -- read port numbers
portRegex = re.compile(
'^\s+(?P<name>\w+).+:\s+(?P<port>\d+)\shttp\S+$')
deadline = startupTimeout + time.time()
serverLines = utils.nonblocking_readline(self.__serverOutput)
while deadline > time.time():
line = next(serverLines)
if line is None:
time.sleep(.1)
continue
parsedLine = portRegex.match(line)
if parsedLine is not None:
if parsedLine.group('name') == 'httpbin':
self.httpbinPort = int(parsedLine.group('port'))
elif parsedLine.group('name') == 'http':
self.httpPort = int(parsedLine.group('port'))
elif parsedLine.group('name') == 'ssl':
self.sslPort = int(parsedLine.group('port'))
if all([self.httpbinPort, self.httpPort, self.sslPort]):
utils.wait_for_port(self.httpPort,
timeout=(deadline - time.time()))
break
else:
raise Exception(
'Timed out waiting %.2f secs for the http server to start' %
startupTimeout)
# -- set an at-exit to make sure we shut ourselves down
atexit.register(self.endServer)
def __init__(self, httpbinPort=0, httpPort=0, sslPort=0, startupTimeout=20):
'''Start a server, using subprocess to do it out-of-process'''
# -- startup server
runableFile = __file__.rstrip('c')
self.__serverOutput = tempfile.NamedTemporaryFile(mode='w+')
self.__serverProcess = subprocess.Popen([runableFile, '--httpbin-port', str(httpbinPort), '--http-port', str(httpPort), '--ssl-port', str(sslPort)], stdout=self.__serverOutput, preexec_fn=os.setpgrp)
# -- read port numbers
portRegex = re.compile('^\s+(?P<name>\w+).+:\s+(?P<port>\d+)\shttp\S+$')
deadline = startupTimeout + time.time()
serverLines = utils.nonblocking_readline(self.__serverOutput)
while deadline > time.time():
line = next(serverLines)
if line is None:
time.sleep(.1)
continue
parsedLine = portRegex.match(line)
if parsedLine is not None:
if parsedLine.group('name') == 'httpbin':
self.httpbinPort = int(parsedLine.group('port'))
elif parsedLine.group('name') == 'http':
self.httpPort = int(parsedLine.group('port'))
elif parsedLine.group('name') == 'ssl':
self.sslPort = int(parsedLine.group('port'))
if all([self.httpbinPort, self.httpPort, self.sslPort]):
utils.wait_for_port(self.httpPort, timeout=(deadline - time.time()))
break
else:
raise Exception('Timed out waiting %.2f secs for the http server to start' % startupTimeout)
# -- set an at-exit to make sure we shut ourselves down
atexit.register(self.endServer)
baseURL = 'http://%s:%d/' % (server.host, server.http_port)
utils.print_with_time("Getting root")
fetchResult = urllib2.urlopen(baseURL, timeout=2)
fetchData = fetchResult.read()
assert fetchResult.getcode(
) == 200, 'Got a non 200 code when requesting the root: %s' % str(
fetchResult.getcode())
assert fetchResult.headers['content-type'] == 'text/html'
assert '<html' in fetchData, 'Data from root did not include "html": %s' % fetchData
utils.print_with_time("Getting invalid page")
# open a log file iterator and flush out the existing lines
logFile = utils.nonblocking_readline(server.logfile_path)
while next(logFile) is not None:
pass
try:
fetchResult = urllib2.urlopen(os.path.join(baseURL, 'foobar'),
timeout=2)
except urllib2.HTTPError as e:
assert e.code == 403, 'Got a non 403 code when requesting bad url /foobar: %s' % str(
e.code)
else:
assert False, "Did not raise a 403 error code when requesting a bad url"
utils.print_with_time("Checking that the bad access was recorded")
deadline = time.time() + 2
