Ejemplo n.º 1
0
 def handle(self, listener, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         try:
             listener_name = listener.getsockname()
             if not self.cfg.keepalive:
                 req = six.next(parser)
                 self.handle_request(listener_name, req, client, addr)
             else:
                 # keepalive loop
                 proxy_protocol_info = {}
                 while True:
                     req = None
                     with self.timeout_ctx():
                         req = six.next(parser)
                     if not req:
                         break
                     if req.proxy_protocol_info:
                         proxy_protocol_info = req.proxy_protocol_info
                     else:
                         req.proxy_protocol_info = proxy_protocol_info
                     self.handle_request(listener_name, req, client, addr)
         except http.errors.NoMoreData as e:
             self.log.debug("Ignored premature client disconnection. %s", e)
         except StopIteration as e:
             self.log.debug("Closing connection. %s", e)
         except ssl.SSLError:
             exc_info = sys.exc_info()
             # pass to next try-except level
             six.reraise(exc_info[0], exc_info[1], exc_info[2])
         except socket.error:
             exc_info = sys.exc_info()
             # pass to next try-except level
             six.reraise(exc_info[0], exc_info[1], exc_info[2])
         except Exception as e:
             self.handle_error(req, client, addr, e)
     except ssl.SSLError as e:
         if e.args[0] == ssl.SSL_ERROR_EOF:
             self.log.debug("ssl connection closed")
             client.close()
         else:
             self.log.debug("Error processing SSL request.")
             self.handle_error(req, client, addr, e)
     except socket.error as e:
         if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
             self.log.exception("Socket error processing request.")
         else:
             if e.args[0] == errno.ECONNRESET:
                 self.log.debug("Ignoring connection reset")
             else:
                 self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
Ejemplo n.º 2
0
 def handle(self, listener, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         try:
             listener_name = listener.getsockname()
             if not self.cfg.keepalive:
                 req = six.next(parser)
                 self.handle_request(listener_name, req, client, addr)
             else:
                 # keepalive loop
                 proxy_protocol_info = {}
                 while True:
                     req = None
                     with self.timeout_ctx():
                         req = six.next(parser)
                     if not req:
                         break
                     if req.proxy_protocol_info:
                         proxy_protocol_info = req.proxy_protocol_info
                     else:
                         req.proxy_protocol_info = proxy_protocol_info
                     self.handle_request(listener_name, req, client, addr)
         except http.errors.NoMoreData as e:
             self.log.debug("Ignored premature client disconnection. %s", e)
         except StopIteration as e:
             self.log.debug("Closing connection. %s", e)
         except ssl.SSLError:
             exc_info = sys.exc_info()
             # pass to next try-except level
             six.reraise(exc_info[0], exc_info[1], exc_info[2])
         except EnvironmentError:
             exc_info = sys.exc_info()
             # pass to next try-except level
             six.reraise(exc_info[0], exc_info[1], exc_info[2])
         except Exception as e:
             self.handle_error(req, client, addr, e)
     except ssl.SSLError as e:
         if e.args[0] == ssl.SSL_ERROR_EOF:
             self.log.debug("ssl connection closed")
             client.close()
         else:
             self.log.debug("Error processing SSL request.")
             self.handle_error(req, client, addr, e)
     except EnvironmentError as e:
         if e.errno not in (errno.EPIPE, errno.ECONNRESET):
             self.log.exception("Socket error processing request.")
         else:
             if e.errno == errno.ECONNRESET:
                 self.log.debug("Ignoring connection reset")
             else:
                 self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
 def handle(self, listener, client, addr):
     environ = {}
     req = None
     resp = None
     try:
         parser = http.RequestParser(self.cfg, client)
         req = six.next(parser)
         environ, resp = self.handle_request(listener, req, client, addr)
     except http.errors.NoMoreData as e:
         self.log.debug("Ignored premature client disconnection. %s", e)
     except StopIteration as e:
         self.log.debug("Closing connection. %s", e)
     except socket.error as e:
         if e.args[0] != errno.EPIPE:
             self.log.exception("Error processing request.")
         else:
             self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
         try:
             if resp is not None:
                 self.cfg.post_request(self, req, environ, resp)
             else:
                 self.log.exception("Error during post_request.")
         except:
             self.log.exception("Error during post_request.")
Ejemplo n.º 4
0
    def handle(self, listener, client, addr):
        req = None
        try:
            if self.cfg.is_ssl:
                client = ssl.wrap_socket(client, server_side=True,
                    **self.cfg.ssl_options)

            parser = http.RequestParser(self.cfg, client)
            req = six.next(parser)
            self.handle_request(listener, req, client, addr)
        except http.errors.NoMoreData as e:
            self.log.debug("Ignored premature client disconnection. %s", e)
        except StopIteration as e:
            self.log.debug("Closing connection. %s", e)
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_EOF:
                self.log.debug("ssl connection closed")
                client.close()
            else:
                self.log.debug("Error processing SSL request.")
                self.handle_error(req, client, addr, e)
        except socket.error as e:
            if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
                self.log.exception("Socket error processing request.")
            else:
                if e.args[0] == errno.ECONNRESET:
                    self.log.debug("Ignoring connection reset")
                else:
                    self.log.debug("Ignoring EPIPE")
        except Exception as e:
            self.handle_error(req, client, addr, e)
        finally:
            util.close(client)
 def handle(self, listener, client, addr):
     environ = {}
     req = None
     resp = None
     try:
         parser = http.RequestParser(self.cfg, client)
         req = six.next(parser)
         environ, resp = self.handle_request(listener, req, client, addr)
     except http.errors.NoMoreData as e:
         self.log.debug("Ignored premature client disconnection. %s", e)
     except StopIteration as e:
         self.log.debug("Closing connection. %s", e)
     except socket.error as e:
         if e.args[0] != errno.EPIPE:
             self.log.exception("Error processing request.")
         else:
             self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
         try:
             if resp is not None:
                 self.cfg.post_request(self, req, environ, resp)
             else:
                 self.log.exception("Error during post_request.")
         except:
             self.log.exception("Error during post_request.")
Ejemplo n.º 6
0
    def handle(self, listener, client, addr):
        req = None
        try:
            if self.cfg.is_ssl:
                client = ssl.wrap_socket(client,
                                         server_side=True,
                                         **self.cfg.ssl_options)

            parser = http.RequestParser(self.cfg, client)
            req = six.next(parser)
            self.handle_request(listener, req, client, addr)
        except http.errors.NoMoreData as e:
            self.log.debug("Ignored premature client disconnection. %s", e)
        except StopIteration as e:
            self.log.debug("Closing connection. %s", e)
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_EOF:
                self.log.debug("ssl connection closed")
                client.close()
            else:
                self.log.debug("Error processing SSL request.")
                self.handle_error(req, client, addr, e)
        except EnvironmentError as e:
            if e.errno not in (errno.EPIPE, errno.ECONNRESET):
                self.log.exception("Socket error processing request.")
            else:
                if e.errno == errno.ECONNRESET:
                    self.log.debug("Ignoring connection reset")
                else:
                    self.log.debug("Ignoring EPIPE")
        except Exception as e:
            self.handle_error(req, client, addr, e)
        finally:
            util.close(client)
Ejemplo n.º 7
0
 def handle(self, listener, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         try:
             if not self.cfg.keepalive:
                 req = six.next(parser)
                 self.handle_request(listener, req, client, addr)
             else:
                 # keepalive loop
                 while True:
                     req = None
                     with self.timeout_ctx():
                         req = six.next(parser)
                     if not req:
                         break
                     self.handle_request(listener, req, client, addr)
         except http.errors.NoMoreData as e:
             self.log.debug("Ignored premature client disconnection. %s", e)
         except StopIteration as e:
             self.log.debug("Closing connection. %s", e)
         except ssl.SSLError:
             raise  # pass to next try-except level
         except socket.error:
             raise  # pass to next try-except level
         except Exception as e:
             self.handle_error(req, client, addr, e)
     except ssl.SSLError as e:
         if e.args[0] == ssl.SSL_ERROR_EOF:
             self.log.debug("ssl connection closed")
             client.close()
         else:
             self.log.debug("Error processing SSL request.")
             self.handle_error(req, client, addr, e)
     except socket.error as e:
         if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
             self.log.exception("Socket error processing request.")
         else:
             if e.args[0] == errno.ECONNRESET:
                 self.log.debug("Ignoring connection reset")
             else:
                 self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
Ejemplo n.º 8
0
 def chunk(self):
     if not self.iter:
         return b""
     try:
         return six.next(self.iter)
     except StopIteration:
         self.iter = None
         return b""
Ejemplo n.º 9
0
 def handle(self, listener, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         try:
             if not self.cfg.keepalive:
                 req = six.next(parser)
                 self.handle_request_implemented(listener, req, client, addr)
             else:
                 # keepalive loop
                 while True:
                     req = None
                     with self.timeout_ctx():
                         req = six.next(parser)
                     if not req:
                         break
                     self.handle_request_implemented(listener, req, client, addr)
         except http.errors.NoMoreData as e:
             self.log.debug("Ignored premature client disconnection. %s", e)
         except StopIteration as e:
             self.log.debug("Closing connection. %s", e)
         except ssl.SSLError:
             raise  # pass to next try-except level
         except socket.error:
             raise  # pass to next try-except level
         except Exception as e:
             self.handle_error(req, client, addr, e)
     except ssl.SSLError as e:
         if e.args[0] == ssl.SSL_ERROR_EOF:
             self.log.debug("ssl connection closed")
             client.close()
         else:
             self.log.debug("Error processing SSL request.")
             self.handle_error(req, client, addr, e)
     except socket.error as e:
         if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
             self.log.exception("Socket error processing request.")
         else:
             if e.args[0] == errno.ECONNRESET:
                 self.log.debug("Ignoring connection reset")
             else:
                 self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
Ejemplo n.º 10
0
 def match_iter(self, req, body, sizes):
     """\
     This skips sizes because there's its not part of the iter api.
     """
     for line in req.body:
         if b"\n" in line[:-1]:
             raise AssertionError("Embedded new line: %r" % line)
         if line != body[: len(line)]:
             raise AssertionError("Invalid body data read: %r != %r" % (line, body[: len(line)]))
         body = body[len(line) :]
     if len(body):
         raise AssertionError("Failed to read entire body: %r" % body)
     try:
         data = six.next(iter(req.body))
         raise AssertionError("Read data after body finished: %r" % data)
     except StopIteration:
         pass
Ejemplo n.º 11
0
 def match_iter(self, req, body, sizes):
     """\
     This skips sizes because there's its not part of the iter api.
     """
     for line in req.body:
         if b'\n' in line[:-1]:
             raise AssertionError("Embedded new line: %r" % line)
         if line != body[:len(line)]:
             raise AssertionError("Invalid body data read: %r != %r" %
                                  (line, body[:len(line)]))
         body = body[len(line):]
     if len(body):
         raise AssertionError("Failed to read entire body: %r" % body)
     try:
         data = six.next(iter(req.body))
         raise AssertionError("Read data after body finished: %r" % data)
     except StopIteration:
         pass
Ejemplo n.º 12
0
    def handle(self, conn):
        if not conn.init():
            # connection kept alive
            try:
                self._keep.remove(conn)
            except ValueError:
                pass

        keepalive = False
        req = None
        try:
            req = six.next(conn.parser)
            if not req:
                return (False, conn)

            # handle the request
            keepalive = self.handle_request(req, conn)
            if keepalive:
                return (keepalive, conn)
        except http.errors.NoMoreData as e:
            self.log.debug("Ignored premature client disconnection. %s", e)

        except StopIteration as e:
            self.log.debug("Closing connection. %s", e)
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_EOF:
                self.log.debug("ssl connection closed")
                conn.sock.close()
            else:
                self.log.debug("Error processing SSL request.")
                self.handle_error(req, conn.sock, conn.addr, e)

        except socket.error as e:
            if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
                self.log.exception("Socket error processing request.")
            else:
                if e.args[0] == errno.ECONNRESET:
                    self.log.debug("Ignoring connection reset")
                else:
                    self.log.debug("Ignoring connection epipe")
        except Exception as e:
            self.handle_error(req, conn.sock, conn.addr, e)

        return (False, conn)
Ejemplo n.º 13
0
    def handle(self, conn):
        if not conn.init():
            # connection kept alive
            try:
                self._keep.remove(conn)
            except ValueError:
                pass

        keepalive = False
        req = None
        try:
            req = six.next(conn.parser)
            if not req:
                return (False, conn)

            # handle the request
            keepalive = self.handle_request(req, conn)
            if keepalive:
                return (keepalive, conn)
        except http.errors.NoMoreData as e:
            self.log.debug("Ignored premature client disconnection. %s", e)

        except StopIteration as e:
            self.log.debug("Closing connection. %s", e)
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_EOF:
                self.log.debug("ssl connection closed")
                conn.sock.close()
            else:
                self.log.debug("Error processing SSL request.")
                self.handle_error(req, conn.sock, conn.addr, e)

        except socket.error as e:
            if e.args[0] not in (errno.EPIPE, errno.ECONNRESET):
                self.log.exception("Socket error processing request.")
            else:
                if e.args[0] == errno.ECONNRESET:
                    self.log.debug("Ignoring connection reset")
                else:
                    self.log.debug("Ignoring connection epipe")
        except Exception as e:
            self.handle_error(req, conn.sock, conn.addr, e)

        return (False, conn)
Ejemplo n.º 14
0
 def handle(self, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         req = six.next(parser)
         self.handle_request(req, client, addr)
     except http.errors.NoMoreData as e:
         self.log.debug("Ignored premature client disconnection. %s", e)
     except StopIteration as e:
         self.log.debug("Closing connection. %s", e)
     except socket.error as e:
         if e.args[0] != errno.EPIPE:
             self.log.exception("Error processing request.")
         else:
             self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
Ejemplo n.º 15
0
 def handle(self, client, addr):
     req = None
     try:
         parser = http.RequestParser(self.cfg, client)
         req = six.next(parser)
         self.handle_request(req, client, addr)
     except http.errors.NoMoreData as e:
         self.log.debug("Ignored premature client disconnection. %s", e)
     except StopIteration as e:
         self.log.debug("Closing connection. %s", e)
     except socket.error as e:
         if e.args[0] != errno.EPIPE:
             self.log.exception("Error processing request.")
         else:
             self.log.debug("Ignoring EPIPE")
     except Exception as e:
         self.handle_error(req, client, addr, e)
     finally:
         util.close(client)
Ejemplo n.º 16
0
    def read(self, size):
        if not isinstance(size, six.integer_types):
            raise TypeError("size must be an integral type")
        if size < 0:
            raise ValueError("Size must be positive.")
        if size == 0:
            return b""

        if self.parser:
            while self.buf.tell() < size:
                try:
                    self.buf.write(six.next(self.parser))
                except StopIteration:
                    self.parser = None
                    break

        data = self.buf.getvalue()
        ret, rest = data[:size], data[size:]
        self.buf = six.BytesIO()
        self.buf.write(rest)
        return ret
Ejemplo n.º 17
0
    def read(self, size):
        if not isinstance(size, six.integer_types):
            raise TypeError("size must be an integral type")
        if size < 0:
            raise ValueError("Size must be positive.")
        if size == 0:
            return b""

        if self.parser:
            while self.buf.tell() < size:
                try:
                    self.buf.write(six.next(self.parser))
                except StopIteration:
                    self.parser = None
                    break

        data = self.buf.getvalue()
        ret, rest = data[:size], data[size:]
        self.buf = six.BytesIO()
        self.buf.write(rest)
        return ret
Ejemplo n.º 18
0
Archivo: treq.py Proyecto: cloudera/hue
 def check(self, cfg):
     p = RequestParser(cfg, self.send())
     six.next(p)
Ejemplo n.º 19
0
 def check(self, cfg):
     p = RequestParser(cfg, self.send())
     six.next(p)