← Back to branch summary

~ubuntu-branches/debian/jessie/python-eventlet/jessie

« back to all changes in this revision

Viewing changes to eventlet/greenio.py

  • Committer: Bazaar Package Importer
  • Author(s): Stefano Rivera
  • Date: 2011-06-02 16:18:16 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20110602161816-c888ncsqx70pfvfu
Tags: 0.9.15-1
https://launchpad.net/bugs/771512
* New upstream release.
  - Drop all patches, accepted upstream.
* Correct DEP3 headers (first line of Description is the subject)
* Bump Standards-Version to 3.9.2, no changes needed.
* Drop Breaks: ${python:Breaks}, no longer used by dh_python2.
* debian/copyright: Update to DEP5 Format r174.
* Restore doc/modules/zmq.rst and BD on Sphinx 1.0.
* reuseaddr.patch: The logic for deciding whether to use SO_REUSEADDR was
  inverted.
* retry-on-timeout.patch: If an operation times out, try one last time.
  (LP: #771512)

Show diffs side-by-side

added added

removed removed

Lines of Context:
eventlet/greenio.py
174
174
                    return
175
175
                if time.time() >= end:
176
176
                    raise socket.timeout("timed out")
177
 
                trampoline(fd, write=True, timeout=end-time.time(),
178
 
                        timeout_exc=socket.timeout("timed out"))
 
177
                try:
 
178
                    trampoline(fd, write=True, timeout=end-time.time(),
 
179
                            timeout_exc=socket.timeout("timed out"))
 
180
                except socket.timeout, e:
 
181
                    try:
 
182
                        if socket_connect(fd, address):
 
183
                            return
 
184
                        raise e
 
185
                    except:
 
186
                        raise e
179
187
                socket_checkerr(fd)
180
188
 
181
189
    def connect_ex(self, address):
197
205
                        return 0
198
206
                    if time.time() >= end:
199
207
                        raise socket.timeout(errno.EAGAIN)
200
 
                    trampoline(fd, write=True, timeout=end-time.time(),
201
 
                            timeout_exc=socket.timeout(errno.EAGAIN))
 
208
                    try:
 
209
                        trampoline(fd, write=True, timeout=end-time.time(),
 
210
                                timeout_exc=socket.timeout(errno.EAGAIN))
 
211
                    except socket.timeout, e:
 
212
                        try:
 
213
                            if socket_connect(fd, address):
 
214
                                return
 
215
                            raise e
 
216
                        except:
 
217
                            raise e
202
218
                    socket_checkerr(fd)
203
219
                except socket.error, ex:
204
220
                    return get_errno(ex)
218
234
            "makefile instead", DeprecationWarning, stacklevel=2)
219
235
        return self.makefile(*args, **kw)
220
236
 
 
237
    def _read_io(self, fd, f, *args, **kwargs):
 
238
        if self.act_non_blocking:
 
239
            return f(*args, **kwargs)
 
240
        while True:
 
241
            try:
 
242
                return f(*args, **kwargs)
 
243
            except socket.error, e:
 
244
                if get_errno(e) in SOCKET_BLOCKING:
 
245
                    pass
 
246
                # XXX -- Why does recv() do this?
 
247
                elif f == fd.recv and get_errno(e) in SOCKET_CLOSED:
 
248
                    return ''
 
249
                else:
 
250
                    raise
 
251
            try:
 
252
                trampoline(fd, 
 
253
                        read=True, 
 
254
                        timeout=self.gettimeout(), 
 
255
                        timeout_exc=socket.timeout("timed out"))
 
256
            except socket.timeout, e:
 
257
                # Try one last time to see if the timeout is 'real'
 
258
                try:
 
259
                    return f(*args, **kwargs)
 
260
                except:
 
261
                    raise e
 
262
 
221
263
    def recv(self, buflen, flags=0):
222
 
        fd = self.fd
223
 
        if self.act_non_blocking:
224
 
            return fd.recv(buflen, flags)
225
 
        while True:
226
 
            try:
227
 
                return fd.recv(buflen, flags)
228
 
            except socket.error, e:
229
 
                if get_errno(e) in SOCKET_BLOCKING:
230
 
                    pass
231
 
                elif get_errno(e) in SOCKET_CLOSED:
232
 
                    return ''
233
 
                else:
234
 
                    raise
235
 
            trampoline(fd, 
236
 
                read=True, 
237
 
                timeout=self.gettimeout(), 
238
 
                timeout_exc=socket.timeout("timed out"))
 
264
        return self._read_io(self.fd, self.fd.recv, buflen, flags)
239
265
 
240
266
    def recvfrom(self, *args):
241
 
        if not self.act_non_blocking:
242
 
            trampoline(self.fd, read=True, timeout=self.gettimeout(),
243
 
                    timeout_exc=socket.timeout("timed out"))
244
 
        return self.fd.recvfrom(*args)
 
267
        return self._read_io(self.fd, self.fd.recvfrom, *args)
245
268
 
246
269
    def recvfrom_into(self, *args):
247
 
        if not self.act_non_blocking:
248
 
            trampoline(self.fd, read=True, timeout=self.gettimeout(),
249
 
                    timeout_exc=socket.timeout("timed out"))
250
 
        return self.fd.recvfrom_into(*args)
 
270
        return self._read_io(self.fd, self.fd.recvfrom_into, *args)
251
271
 
252
272
    def recv_into(self, *args):
253
 
        if not self.act_non_blocking:
254
 
            trampoline(self.fd, read=True, timeout=self.gettimeout(),
255
 
                    timeout_exc=socket.timeout("timed out"))
256
 
        return self.fd.recv_into(*args)
 
273
        return self._read_io(self.fd, self.fd.recv_into, *args)
257
274
 
258
275
    def send(self, data, flags=0):
259
276
        fd = self.fd
264
281
        total_sent = 0
265
282
        len_data = len(data)
266
283
 
267
 
        while 1:
 
284
        while True:
268
285
            try:
269
286
                total_sent += fd.send(data[total_sent:], flags)
270
287
            except socket.error, e:
274
291
            if total_sent == len_data:
275
292
                break
276
293
 
277
 
            trampoline(self.fd, write=True, timeout=self.gettimeout(),
278
 
                    timeout_exc=socket.timeout("timed out"))
 
294
            try:
 
295
                trampoline(fd, write=True, timeout=self.gettimeout(),
 
296
                        timeout_exc=socket.timeout("timed out"))
 
297
            except socket.timeout, e:
 
298
                # Try one last time to see if the timeout is 'real'
 
299
                try:
 
300
                    total_sent += fd.send(data[total_sent:], flags)
 
301
                except:
 
302
                    raise e
279
303
 
280
304
        return total_sent
281
305
 
286
310
            tail += self.send(data[tail:], flags)
287
311
 
288
312
    def sendto(self, *args):
289
 
        trampoline(self.fd, write=True)
290
 
        return self.fd.sendto(*args)
 
313
        fd = self.fd
 
314
        if self.act_non_blocking:
 
315
            return fd.sendto(*args)
 
316
        while True:
 
317
            try:
 
318
                return fd.sendto(*args)
 
319
            except socket.error, e:
 
320
                if get_errno(e) in SOCKET_BLOCKING:
 
321
                    pass
 
322
                else:
 
323
                    raise
 
324
            try:
 
325
                trampoline(fd, write=True, timeout=self.gettimeout(),
 
326
                        timeout_exc=socket.timeout("timed out"))
 
327
            except socket.timeout, e:
 
328
                # Try one last time to see if the timeout is 'real'
 
329
                try:
 
330
                    return fd.sendto(*args)
 
331
                except:
 
332
                    raise e
291
333
 
292
334
    def setblocking(self, flag):
293
335
        if flag: