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 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 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 set_launchpad_default_timeout(event): """Set the LAZR default timeout function on IProcessStartingEvent.""" set_default_timeout_function(get_request_remaining_seconds)