Lines Matching refs:request

15 For request-based servers (including socket-based):
17 - client address verification before further looking at the request
19          at the request before anything else, e.g. logging)
21         - synchronous (one request is handled at a time)
22         - forking (each request is handled by a new process)
23         - threading (each request is handled by a new thread)
65 with your request handler class.
67 The request handler class must be different for datagram or stream
68 services.  This can be hidden by using the request handler
83 class will essentially render the service "deaf" while one request is
88 In some cases, it may be appropriate to process part of a request
90 the request data.  This can be implemented by using a synchronous
91 server and doing an explicit fork in the request handler class
98 decide which request to work on next (or whether to handle a new
99 incoming request).  This is particularly important for stream services
112 - split generic "request" functionality out into BaseServer class.
169     - get_request() -> request, client_address
171     - verify_request(request, client_address)
173     - process_request(request, client_address)
174     - shutdown_request(request)
175     - close_request(request)
181     - finish_request(request, client_address)
217         """Handle one request at a time until shutdown.
227             # responsiveness to a shutdown request and wastes cpu at all other
264     # request is fairly arbitrary.  Remember:
270     #   new thread to finish the request
271     # - finish_request() instantiates the request handler class; this
272     #   constructor will handle the request all by itself
275         """Handle one request, possibly blocking.
289         # Wait until a request arrives or the timeout expires - the loop is
305         """Handle one request, without blocking.
312             request, client_address = self.get_request()
315         if self.verify_request(request, client_address):
317                 self.process_request(request, client_address)
319                 self.handle_error(request, client_address)
320                 self.shutdown_request(request)
322                 self.shutdown_request(request)
325             self.shutdown_request(request)
328         """Called if no new request arrives within self.timeout.
334     def verify_request(self, request, client_address):
335         """Verify the request.  May be overridden.
337         Return True if we should proceed with this request.
342     def process_request(self, request, client_address):
348         self.finish_request(request, client_address)
349         self.shutdown_request(request)
359     def finish_request(self, request, client_address):
360         """Finish one request by instantiating RequestHandlerClass."""
361         self.RequestHandlerClass(request, client_address, self)
363     def shutdown_request(self, request):
364         """Called to shutdown and close an individual request."""
365         self.close_request(request)
367     def close_request(self, request):
368         """Called to clean up an individual request."""
371     def handle_error(self, request, client_address):
378         print('Exception occurred during processing of request from',
409     - get_request() -> request, client_address
411     - verify_request(request, client_address)
412     - process_request(request, client_address)
413     - shutdown_request(request)
414     - close_request(request)
419     - finish_request(request, client_address)
500         """Get the request and client address from the socket.
507     def shutdown_request(self, request):
508         """Called to shutdown and close an individual request."""
512             request.shutdown(socket.SHUT_WR)
515         self.close_request(request)
517     def close_request(self, request):
518         """Called to clean up an individual request."""
519         request.close()
542     def shutdown_request(self, request):
544         self.close_request(request)
546     def close_request(self, request):
552         """Mix-in class to handle each request in a new process."""
609         def process_request(self, request, client_address):
610             """Fork a new subprocess to process the request."""
617                 self.close_request(request)
624                     self.finish_request(request, client_address)
627                     self.handle_error(request, client_address)
630                         self.shutdown_request(request)
673     """Mix-in class to handle each request in a new thread."""
684     def process_request_thread(self, request, client_address):
691             self.finish_request(request, client_address)
693             self.handle_error(request, client_address)
695             self.shutdown_request(request)
697     def process_request(self, request, client_address):
698         """Start a new thread to process the request."""
702                              args = (request, client_address))
733     """Base class for request handler classes.
735     This class is instantiated for each request to be handled.  The
736     constructor sets the instance variables request, client_address
741     The handle() method can find the request as self.request, the
744     separate instance is created for each request, the handle() method
749     def __init__(self, request, client_address, server):
750         self.request = request
772 # - rfile: a file object from which receives the request is read
791     # A timeout to apply to the request socket, if not None.
799         self.connection = self.request
847         self.packet, self.socket = self.request