don't use autoinstall to import pywebsocket but check it in WebKit directly.
[WebKit-https.git] / Tools / Scripts / webkitpy / thirdparty / mod_pywebsocket / _stream_base.py
1 # Copyright 2011, Google Inc.
2 # All rights reserved.
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met:
7 #
8 #     * Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 # copyright notice, this list of conditions and the following disclaimer
12 # in the documentation and/or other materials provided with the
13 # distribution.
14 #     * Neither the name of Google Inc. nor the names of its
15 # contributors may be used to endorse or promote products derived from
16 # this software without specific prior written permission.
17 #
18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31 """Base stream class.
32 """
33
34
35 # Note: request.connection.write/read are used in this module, even though
36 # mod_python document says that they should be used only in connection
37 # handlers. Unfortunately, we have no other options. For example,
38 # request.write/read are not suitable because they don't allow direct raw bytes
39 # writing/reading.
40
41
42 from mod_pywebsocket import util
43
44
45 # Exceptions
46
47
48 class ConnectionTerminatedException(Exception):
49     """This exception will be raised when a connection is terminated
50     unexpectedly.
51     """
52
53     pass
54
55
56 class InvalidFrameException(ConnectionTerminatedException):
57     """This exception will be raised when we received an invalid frame we
58     cannot parse.
59     """
60
61     pass
62
63
64 class BadOperationException(Exception):
65     """This exception will be raised when send_message() is called on
66     server-terminated connection or receive_message() is called on
67     client-terminated connection.
68     """
69
70     pass
71
72
73 class UnsupportedFrameException(Exception):
74     """This exception will be raised when we receive a frame with flag, opcode
75     we cannot handle. Handlers can just catch and ignore this exception and
76     call receive_message() again to continue processing the next frame.
77     """
78
79     pass
80
81
82 class InvalidUTF8Exception(Exception):
83     """This exception will be raised when we receive a text frame which
84     contains invalid UTF-8 strings.
85     """
86
87     pass
88
89
90 class StreamBase(object):
91     """Base stream class."""
92
93     def __init__(self, request):
94         """Construct an instance.
95
96         Args:
97             request: mod_python request.
98         """
99
100         self._logger = util.get_class_logger(self)
101
102         self._request = request
103
104     def _read(self, length):
105         """Reads length bytes from connection. In case we catch any exception,
106         prepends remote address to the exception message and raise again.
107
108         Raises:
109             ConnectionTerminatedException: when read returns empty string.
110         """
111
112         bytes = self._request.connection.read(length)
113         if not bytes:
114             raise ConnectionTerminatedException(
115                 'Receiving %d byte failed. Peer (%r) closed connection' %
116                 (length, (self._request.connection.remote_addr,)))
117         return bytes
118
119     def _write(self, bytes):
120         """Writes given bytes to connection. In case we catch any exception,
121         prepends remote address to the exception message and raise again.
122         """
123
124         try:
125             self._request.connection.write(bytes)
126         except Exception, e:
127             util.prepend_message_to_exception(
128                     'Failed to send message to %r: ' %
129                             (self._request.connection.remote_addr,),
130                     e)
131             raise
132
133     def receive_bytes(self, length):
134         """Receives multiple bytes. Retries read when we couldn't receive the
135         specified amount.
136
137         Raises:
138             ConnectionTerminatedException: when read returns empty string.
139         """
140
141         bytes = []
142         while length > 0:
143             new_bytes = self._read(length)
144             bytes.append(new_bytes)
145             length -= len(new_bytes)
146         return ''.join(bytes)
147
148     def _read_until(self, delim_char):
149         """Reads bytes until we encounter delim_char. The result will not
150         contain delim_char.
151
152         Raises:
153             ConnectionTerminatedException: when read returns empty string.
154         """
155
156         bytes = []
157         while True:
158             ch = self._read(1)
159             if ch == delim_char:
160                 break
161             bytes.append(ch)
162         return ''.join(bytes)
163
164
165 # vi:sts=4 sw=4 et