← Back to branch summary

~ubuntu-branches/ubuntu/raring/python-eventlet/raring-proposed

« back to all changes in this revision

Viewing changes to eventlet/greenio.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-07 19:25:01 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120807192501-yr28amkyjp85u0jg
Tags: 0.9.17-0ubuntu1
* New upstream reversion:
  - debian/patches/threading-leak: dropped no longer needed.
  - debian/patches/retry-on-timeout: dropped no longer needed.

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
 
                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
 
177
                trampoline(fd, write=True, timeout=end-time.time(),
 
178
                        timeout_exc=socket.timeout("timed out"))
187
179
                socket_checkerr(fd)
188
180
 
189
181
    def connect_ex(self, address):
205
197
                        return 0
206
198
                    if time.time() >= end:
207
199
                        raise 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
 
200
                    trampoline(fd, write=True, timeout=end-time.time(),
 
201
                            timeout_exc=socket.timeout(errno.EAGAIN))
218
202
                    socket_checkerr(fd)
219
203
                except socket.error, ex:
220
204
                    return get_errno(ex)
234
218
            "makefile instead", DeprecationWarning, stacklevel=2)
235
219
        return self.makefile(*args, **kw)
236
220
 
237
 
    def _read_io(self, fd, f, *args, **kwargs):
 
221
    def recv(self, buflen, flags=0):
 
222
        fd = self.fd
238
223
        if self.act_non_blocking:
239
 
            return f(*args, **kwargs)
 
224
            return fd.recv(buflen, flags)
240
225
        while True:
241
226
            try:
242
 
                return f(*args, **kwargs)
 
227
                return fd.recv(buflen, flags)
243
228
            except socket.error, e:
244
229
                if get_errno(e) in SOCKET_BLOCKING:
245
230
                    pass
246
 
                # XXX -- Why does recv() do this?
247
 
                elif f == fd.recv and get_errno(e) in SOCKET_CLOSED:
 
231
                elif get_errno(e) in SOCKET_CLOSED:
248
232
                    return ''
249
233
                else:
250
234
                    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
 
 
263
 
    def recv(self, buflen, flags=0):
264
 
        return self._read_io(self.fd, self.fd.recv, buflen, flags)
 
235
            trampoline(fd, 
 
236
                read=True, 
 
237
                timeout=self.gettimeout(), 
 
238
                timeout_exc=socket.timeout("timed out"))
265
239
 
266
240
    def recvfrom(self, *args):
267
 
        return self._read_io(self.fd, self.fd.recvfrom, *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)
268
245
 
269
246
    def recvfrom_into(self, *args):
270
 
        return self._read_io(self.fd, self.fd.recvfrom_into, *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)
271
251
 
272
252
    def recv_into(self, *args):
273
 
        return self._read_io(self.fd, self.fd.recv_into, *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)
274
257
 
275
258
    def send(self, data, flags=0):
276
259
        fd = self.fd
281
264
        total_sent = 0
282
265
        len_data = len(data)
283
266
 
284
 
        while True:
 
267
        while 1:
285
268
            try:
286
269
                total_sent += fd.send(data[total_sent:], flags)
287
270
            except socket.error, e:
291
274
            if total_sent == len_data:
292
275
                break
293
276
 
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
 
277
            trampoline(self.fd, write=True, timeout=self.gettimeout(),
 
278
                    timeout_exc=socket.timeout("timed out"))
303
279
 
304
280
        return total_sent
305
281
 
310
286
            tail += self.send(data[tail:], flags)
311
287
 
312
288
    def sendto(self, *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
 
289
        trampoline(self.fd, write=True)
 
290
        return self.fd.sendto(*args)
333
291
 
334
292
    def setblocking(self, flag):
335
293
        if flag: