def test_reduced_timeout(self):
"""reduced_timeout caps the available timeout in various ways."""
self.addCleanup(set_default_timeout_function, None)
with reduced_timeout(1.0):
self.assertIsNone(get_default_timeout_function()())
with reduced_timeout(1.0, default=5.0):
self.assertEqual(5.0, get_default_timeout_function()())
set_default_timeout_function(lambda: 5.0)
with reduced_timeout(1.0):
self.assertEqual(4.0, get_default_timeout_function()())
with reduced_timeout(1.0, default=5.0, webapp_max=2.0):
self.assertEqual(4.0, get_default_timeout_function()())
with reduced_timeout(1.0, default=5.0, webapp_max=6.0):
self.assertEqual(4.0, get_default_timeout_function()())
with reduced_timeout(6.0, default=5.0, webapp_max=2.0):
self.assertEqual(5.0, get_default_timeout_function()())
LaunchpadTestRequest()
set_request_started()
try:
with reduced_timeout(1.0):
self.assertEqual(4.0, get_default_timeout_function()())
with reduced_timeout(1.0, default=5.0, webapp_max=2.0):
self.assertEqual(2.0, get_default_timeout_function()())
with reduced_timeout(1.0, default=5.0, webapp_max=6.0):
self.assertEqual(4.0, get_default_timeout_function()())
with reduced_timeout(6.0, default=5.0, webapp_max=2.0):
self.assertEqual(2.0, get_default_timeout_function()())
finally:
clear_request_started()
def main(self):
force_bzr_to_use_urllib()
set_default_timeout_function(lambda: 60.0)
source_details = CodeImportSourceDetails.fromArguments(self.args)
if source_details.rcstype == 'git':
if source_details.target_rcstype == 'bzr':
import_worker_cls = GitImportWorker
else:
import_worker_cls = GitToGitImportWorker
elif source_details.rcstype == 'bzr-svn':
import_worker_cls = BzrSvnImportWorker
elif source_details.rcstype == 'bzr':
import_worker_cls = BzrImportWorker
elif source_details.rcstype == 'cvs':
import_worker_cls = CSCVSImportWorker
else:
raise AssertionError('unknown rcstype %r' % source_details.rcstype)
opener_policy = opener_policies[self.options.access_policy](
source_details.rcstype, source_details.target_rcstype)
if source_details.target_rcstype == 'bzr':
import_worker = import_worker_cls(
source_details,
get_transport(config.codeimport.foreign_tree_store),
get_default_bazaar_branch_store(), self.logger, opener_policy)
else:
import_worker = import_worker_cls(source_details, self.logger,
opener_policy)
return import_worker.run()
def setUp(self):
super(HTTPWalker_ListDir, self).setUp()
self.addCleanup(reset_logging)
original_timeout_function = get_default_timeout_function()
set_default_timeout_function(lambda: 60.0)
self.addCleanup(
set_default_timeout_function, original_timeout_function)
def test_xmlrpc_transport(self):
""" Another use case for timeouts is communicating with external
systems using XMLRPC. In order to allow timeouts using XMLRPC we
provide a transport that is timeout-aware. The Transport is used for
XMLRPC over HTTP.
"""
# Create a socket bound to a random port, just to obtain a free port.
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
sock, http_server_url = self.make_test_socket()
addr, port = sock.getsockname()
sock.close()
server = MySimpleXMLRPCServer(
('127.0.0.1', port),
requestHandler=EchoOrWaitXMLRPCReqHandler,
logRequests=False)
server_thread = threading.Thread(target=server.serve_2_requests)
server_thread.start()
proxy = xmlrpclib.ServerProxy(http_server_url,
transport=TransportWithTimeout())
self.assertEqual('Successful test message.',
proxy.echo('Successful test message.'))
self.assertRaises(TimeoutError, proxy.no_response,
'Unsuccessful test message.')
server_thread.join()
def test_override_timeout(self):
"""override_timeout temporarily overrides the default timeout."""
self.addCleanup(set_default_timeout_function, None)
with override_timeout(1.0):
self.assertEqual(1.0, get_default_timeout_function()())
set_default_timeout_function(lambda: 5.0)
with override_timeout(1.0):
self.assertEqual(1.0, get_default_timeout_function()())
def test_default_timeout(self):
"""default_timeout sets the default timeout if none is set."""
self.addCleanup(set_default_timeout_function, None)
with default_timeout(1.0):
self.assertEqual(1.0, get_default_timeout_function()())
set_default_timeout_function(lambda: 5.0)
with default_timeout(1.0):
self.assertEqual(5.0, get_default_timeout_function()())
def runJob(self, job, fallback):
original_timeout_function = get_default_timeout_function()
if job.lease_expires is not None:
set_default_timeout_function(lambda: job.getTimeout())
try:
super(BaseJobRunner, self).runJob(IRunnableJob(job), fallback)
finally:
set_default_timeout_function(original_timeout_function)
def mockRequests(self, method, set_default_timeout=True, **kwargs):
with responses.RequestsMock() as requests_mock:
requests_mock.add(method, re.compile(r".*"), **kwargs)
original_timeout_function = get_default_timeout_function()
if set_default_timeout:
set_default_timeout_function(lambda: 60.0)
try:
yield
finally:
set_default_timeout_function(original_timeout_function)
self.requests = [call.request for call in requests_mock.calls]
def main(self):
globalErrorUtility.configure(self.name)
set_default_timeout_function(
lambda: config.request_daily_builds.timeout)
source = getUtility(ISourcePackageRecipeBuildSource)
builds = source.makeDailyBuilds(self.logger)
self.logger.info('Requested %d daily recipe builds.' % len(builds))
builds = getUtility(ISnapSet).makeAutoBuilds(self.logger)
self.logger.info('Requested %d automatic snap package builds.' %
len(builds))
transaction.commit()
def test_set_default_timeout(self):
"""the set_default_timeout_function() takes a function that should return
the number of seconds to wait.
"""
using_default = []
def my_default_timeout():
using_default.append(True)
return 1
set_default_timeout_function(my_default_timeout)
self.addCleanup(set_default_timeout_function, None)
no_default_timeout()
self.assertEqual([True], using_default)
def test_set_default_timeout(self):
"""the set_default_timeout_function() takes a function that should return
the number of seconds to wait.
"""
using_default = []
def my_default_timeout():
using_default.append(True)
return 1
set_default_timeout_function(my_default_timeout)
self.addCleanup(set_default_timeout_function, None)
no_default_timeout()
self.assertEqual([True], using_default)
def main(self):
if self.options.content_type == 'archive':
content_type = MirrorContent.ARCHIVE
elif self.options.content_type == 'cdimage':
content_type = MirrorContent.RELEASE
else:
raise LaunchpadScriptFailure(
'Wrong value for argument --content-type: %s' %
self.options.content_type)
set_default_timeout_function(
lambda: config.distributionmirrorprober.timeout)
DistroMirrorProber(self.txn, self.logger).probe(
content_type, self.options.no_remote_hosts, self.options.force,
self.options.max_mirrors, not self.options.no_owner_notification)
def make_test_socket(self):
"""One common use case for timing out is when making an HTTP request to
an external site to fetch content. To this end, the timeout module has
a urlfetch() function that retrieve a URL using custom urllib2 handlers
that will timeout using the default timeout function and clean-up the
socket properly.
"""
sock = socket.socket()
sock.settimeout(2)
sock.bind(('127.0.0.1', 0))
# Use 1s as default timeout.
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
http_server_url = 'http://%s:%d/' % sock.getsockname()
return sock, http_server_url
def make_test_socket(self):
"""One common use case for timing out is when making an HTTP request to
an external site to fetch content. To this end, the timeout module has
a urlfetch() function that retrieve a URL using custom urllib2 handlers
that will timeout using the default timeout function and clean-up the
socket properly.
"""
sock = socket.socket()
sock.settimeout(2)
sock.bind(('127.0.0.1', 0))
# Use 1s as default timeout.
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
http_server_url = 'http://%s:%d/' % sock.getsockname()
return sock, http_server_url
def test_retrieveKey_raises_GPGKeyTemporarilyNotFoundError_for_timeout(
self):
# If the keyserver responds too slowly, GPGHandler.retrieveKey()
# raises GPGKeyTemporarilyNotFoundError.
self.useFixture(KeyServerTac())
old_timeout_function = get_default_timeout_function()
set_default_timeout_function(lambda: 0.01)
try:
gpghandler = getUtility(IGPGHandler)
self.assertRaises(GPGKeyTemporarilyNotFoundError,
gpghandler.retrieveKey, 'non-existent-fp')
# An OOPS report is generated for the timeout.
error_report = self.oopses[-1]
self.assertEqual('TimeoutError', error_report['type'])
self.assertEqual('timeout exceeded.', error_report['value'])
finally:
set_default_timeout_function(old_timeout_function)
def test_retrieveKey_raises_GPGKeyTemporarilyNotFoundError_for_timeout(
self):
# If the keyserver responds too slowly, GPGHandler.retrieveKey()
# raises GPGKeyTemporarilyNotFoundError.
self.useFixture(KeyServerTac())
old_timeout_function = get_default_timeout_function()
set_default_timeout_function(lambda: 0.01)
try:
gpghandler = getUtility(IGPGHandler)
self.assertRaises(
GPGKeyTemporarilyNotFoundError, gpghandler.retrieveKey,
'non-existent-fp')
# An OOPS report is generated for the timeout.
error_report = self.oopses[-1]
self.assertEqual('TimeoutError', error_report['type'])
self.assertEqual('timeout exceeded.', error_report['value'])
finally:
set_default_timeout_function(old_timeout_function)
def test_runJob_sets_default_timeout_function(self):
"""runJob sets a default timeout function for urlfetch."""
class RecordDefaultTimeoutJob(NullJob):
def __init__(self):
super(RecordDefaultTimeoutJob, self).__init__("")
def run(self):
self.default_timeout = get_default_timeout_function()()
original_timeout_function = get_default_timeout_function()
set_default_timeout_function(None)
try:
job = RecordDefaultTimeoutJob()
job.job.acquireLease()
JobRunner([job]).runJob(job, None)
self.assertEqual(JobStatus.COMPLETED, job.job.status)
self.assertThat(job.default_timeout, GreaterThan(0))
finally:
set_default_timeout_function(original_timeout_function)
def test_timeout(self):
# The time permitted to get the diff from the librarian may be None,
# or 2. If there is not 2 seconds left in the request, the number will
# be 0.01 smaller or the actual remaining time.
class DiffWithFakeText(Diff):
diff_text = FakeMethod()
diff = DiffWithFakeText()
diff.diff_text.open = FakeMethod()
diff.diff_text.read = FakeMethod()
diff.diff_text.close = FakeMethod()
value = None
original_timeout_function = get_default_timeout_function()
set_default_timeout_function(lambda: value)
try:
LaunchpadTestRequest()
set_request_started()
try:
diff.text
self.assertEqual(
LIBRARIAN_SERVER_DEFAULT_TIMEOUT,
diff.diff_text.open.calls[-1][0][0])
value = 3.1
diff.text
self.assertEqual(2.0, diff.diff_text.open.calls[-1][0][0])
value = 1.11
diff.text
self.assertEqual(1.1, diff.diff_text.open.calls[-1][0][0])
value = 0.11
diff.text
self.assertEqual(0.1, diff.diff_text.open.calls[-1][0][0])
value = 0.01
diff.text
self.assertEqual(0.01, diff.diff_text.open.calls[-1][0][0])
finally:
clear_request_started()
finally:
set_default_timeout_function(original_timeout_function)
def test_xmlrpc_transport(self):
""" Another use case for timeouts is communicating with external
systems using XMLRPC. In order to allow timeouts using XMLRPC we
provide a transport that is timeout-aware. The Transport is used for
XMLRPC over HTTP.
"""
# Create a socket bound to a random port, just to obtain a free port.
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
sock, http_server_url = self.make_test_socket()
addr, port = sock.getsockname()
sock.close()
server = MySimpleXMLRPCServer(('127.0.0.1', port),
requestHandler=EchoOrWaitXMLRPCReqHandler,
logRequests=False)
server_thread = threading.Thread(target=server.serve_2_requests)
server_thread.start()
proxy = xmlrpclib.ServerProxy(http_server_url,
transport=TransportWithTimeout())
self.assertEqual('Successful test message.',
proxy.echo('Successful test message.'))
self.assertRaises(TimeoutError,
proxy.no_response, 'Unsuccessful test message.')
server_thread.join()
def test_urlfetch_only_supports_http_urls(self):
"""urlfetch() only supports http urls:"""
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
e = self.assertRaises(AssertionError, urlfetch, 'ftp://localhost')
self.assertEqual('only http is supported.', str(e))
def test_urlfetch_only_supports_http_urls(self):
"""urlfetch() only supports http urls:"""
set_default_timeout_function(lambda: 1)
self.addCleanup(set_default_timeout_function, None)
e = self.assertRaises(AssertionError, urlfetch, 'ftp://localhost')
self.assertEqual('only http is supported.', str(e))
def set_launchpad_default_timeout(event):
"""Set the LAZR default timeout function on IProcessStartingEvent."""
set_default_timeout_function(get_request_remaining_seconds)
def set_launchpad_default_timeout(event):
"""Set the LAZR default timeout function on IProcessStartingEvent."""
set_default_timeout_function(get_request_remaining_seconds)
