Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Lib/SocketServer.py

    r2 r388  
    8383class will essentially render the service "deaf" while one request is
    8484being handled -- which may be for a very long time if a client is slow
    85 to reqd all the data it has requested.  Here a threading or forking
     85to read all the data it has requested.  Here a threading or forking
    8686server is appropriate.
    8787
    … …  
    134134import sys
    135135import os
     136import errno
    136137try:
    137138    import threading
    … …  
    148149                    "ThreadingUnixDatagramServer"])
    149150
     151def _eintr_retry(func, *args):
     152    """restart a system call interrupted by EINTR"""
     153    while True:
     154        try:
     155            return func(*args)
     156        except (OSError, select.error) as e:
     157            if e.args[0] != errno.EINTR:
     158                raise
     159
    150160class BaseServer:
    151161
    … …  
    169179    - server_close()
    170180    - process_request(request, client_address)
     181    - shutdown_request(request)
    171182    - close_request(request)
    172183    - handle_error()
    … …  
    198209        self.RequestHandlerClass = RequestHandlerClass
    199210        self.__is_shut_down = threading.Event()
    200         self.__serving = False
     211        self.__shutdown_request = False
    201212
    202213    def server_activate(self):
    … …  
    215226        another thread.
    216227        """
    217         self.__serving = True
    218228        self.__is_shut_down.clear()
    219         while self.__serving:
    220             # XXX: Consider using another file descriptor or
    221             # connecting to the socket to wake this up instead of
    222             # polling. Polling reduces our responsiveness to a
    223             # shutdown request and wastes cpu at all other times.
    224             r, w, e = select.select([self], [], [], poll_interval)
    225             if r:
    226                 self._handle_request_noblock()
    227         self.__is_shut_down.set()
     229        try:
     230            while not self.__shutdown_request:
     231                # XXX: Consider using another file descriptor or
     232                # connecting to the socket to wake this up instead of
     233                # polling. Polling reduces our responsiveness to a
     234                # shutdown request and wastes cpu at all other times.
     235                r, w, e = _eintr_retry(select.select, [self], [], [],
     236                                       poll_interval)
     237                if self in r:
     238                    self._handle_request_noblock()
     239        finally:
     240            self.__shutdown_request = False
     241            self.__is_shut_down.set()
    228242
    229243    def shutdown(self):
    … …  
    234248        deadlock.
    235249        """
    236         self.__serving = False
     250        self.__shutdown_request = True
    237251        self.__is_shut_down.wait()
    238252
    … …  
    260274        elif self.timeout is not None:
    261275            timeout = min(timeout, self.timeout)
    262         fd_sets = select.select([self], [], [], timeout)
     276        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)
    263277        if not fd_sets[0]:
    264278            self.handle_timeout()
    … …  
    282296            except:
    283297                self.handle_error(request, client_address)
    284                 self.close_request(request)
     298                self.shutdown_request(request)
    285299
    286300    def handle_timeout(self):
    … …  
    306320        """
    307321        self.finish_request(request, client_address)
    308         self.close_request(request)
     322        self.shutdown_request(request)
    309323
    310324    def server_close(self):
    … …  
    319333        """Finish one request by instantiating RequestHandlerClass."""
    320334        self.RequestHandlerClass(request, client_address, self)
     335
     336    def shutdown_request(self, request):
     337        """Called to shutdown and close an individual request."""
     338        self.close_request(request)
    321339
    322340    def close_request(self, request):
    … …  
    360378    - verify_request(request, client_address)
    361379    - process_request(request, client_address)
     380    - shutdown_request(request)
    362381    - close_request(request)
    363382    - handle_error()
    … …  
    444463        return self.socket.accept()
    445464
     465    def shutdown_request(self, request):
     466        """Called to shutdown and close an individual request."""
     467        try:
     468            #explicitly shutdown.  socket.close() merely releases
     469            #the socket and waits for GC to perform the actual close.
     470            request.shutdown(socket.SHUT_WR)
     471        except socket.error:
     472            pass #some platforms may raise ENOTCONN here
     473        self.close_request(request)
     474
    446475    def close_request(self, request):
    447476        """Called to clean up an individual request."""
    … …  
    466495        # No need to call listen() for UDP.
    467496        pass
     497
     498    def shutdown_request(self, request):
     499        # No need to shutdown anything.
     500        self.close_request(request)
    468501
    469502    def close_request(self, request):
    … …  
    527560                self.active_children = []
    528561            self.active_children.append(pid)
    529             self.close_request(request)
     562            self.close_request(request) #close handle in parent process
    530563            return
    531564        else:
    … …  
    534567            try:
    535568                self.finish_request(request, client_address)
     569                self.shutdown_request(request)
    536570                os._exit(0)
    537571            except:
    538572                try:
    539573                    self.handle_error(request, client_address)
     574                    self.shutdown_request(request)
    540575                finally:
    541576                    os._exit(1)
    … …  
    557592        try:
    558593            self.finish_request(request, client_address)
    559             self.close_request(request)
     594            self.shutdown_request(request)
    560595        except:
    561596            self.handle_error(request, client_address)
    562             self.close_request(request)
     597            self.shutdown_request(request)
    563598
    564599    def process_request(self, request, client_address):
    … …  
    566601        t = threading.Thread(target = self.process_request_thread,
    567602                             args = (request, client_address))
    568         if self.daemon_threads:
    569             t.setDaemon (1)
     603        t.daemon = self.daemon_threads
    570604        t.start()
    571605
    … …  
    611645        self.client_address = client_address
    612646        self.server = server
     647        self.setup()
    613648        try:
    614             self.setup()
    615649            self.handle()
     650        finally:
    616651            self.finish()
    617         finally:
    618             sys.exc_traceback = None    # Help garbage collection
    619652
    620653    def setup(self):
    … …  
    650683    wbufsize = 0
    651684
     685    # A timeout to apply to the request socket, if not None.
     686    timeout = None
     687
     688    # Disable nagle algorithm for this socket, if True.
     689    # Use only when wbufsize != 0, to avoid small packets.
     690    disable_nagle_algorithm = False
     691
    652692    def setup(self):
    653693        self.connection = self.request
     694        if self.timeout is not None:
     695            self.connection.settimeout(self.timeout)
     696        if self.disable_nagle_algorithm:
     697            self.connection.setsockopt(socket.IPPROTO_TCP,
     698                                       socket.TCP_NODELAY, True)
    654699        self.rfile = self.connection.makefile('rb', self.rbufsize)
    655700        self.wfile = self.connection.makefile('wb', self.wbufsize)
    … …  
    657702    def finish(self):
    658703        if not self.wfile.closed:
    659             self.wfile.flush()
     704            try:
     705                self.wfile.flush()
     706            except socket.error:
     707                # An final socket error may have occurred here, such as
     708                # the local error ECONNABORTED.
     709                pass
    660710        self.wfile.close()
    661711        self.rfile.close()
Note: See TracChangeset for help on using the changeset viewer.