blob: 684e5d284f4d804a263fe641d149d121defa6129 [file] [log] [blame]
Fred Drake526a1822000-09-11 04:00:46 +00001# -*- Mode: Python -*-
Tim Peters146965a2001-01-14 18:09:23 +00002# Id: asyncore.py,v 2.51 2000/09/07 22:29:26 rushing Exp
Fred Drake526a1822000-09-11 04:00:46 +00003# Author: Sam Rushing <rushing@nightmare.com>
Guido van Rossum0039d7b1999-01-12 20:19:27 +00004
5# ======================================================================
6# Copyright 1996 by Sam Rushing
Tim Peters146965a2001-01-14 18:09:23 +00007#
Guido van Rossum0039d7b1999-01-12 20:19:27 +00008# All Rights Reserved
Tim Peters146965a2001-01-14 18:09:23 +00009#
Guido van Rossum0039d7b1999-01-12 20:19:27 +000010# Permission to use, copy, modify, and distribute this software and
11# its documentation for any purpose and without fee is hereby
12# granted, provided that the above copyright notice appear in all
13# copies and that both that copyright notice and this permission
14# notice appear in supporting documentation, and that the name of Sam
15# Rushing not be used in advertising or publicity pertaining to
16# distribution of the software without specific, written prior
17# permission.
Tim Peters146965a2001-01-14 18:09:23 +000018#
Guido van Rossum0039d7b1999-01-12 20:19:27 +000019# SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
20# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
21# NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
22# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
23# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
24# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
25# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
26# ======================================================================
27
Guido van Rossum4b8c6ea2000-02-04 15:39:30 +000028"""Basic infrastructure for asynchronous socket service clients and servers.
29
30There are only two ways to have a program on a single processor do "more
Tim Peters146965a2001-01-14 18:09:23 +000031than one thing at a time". Multi-threaded programming is the simplest and
Guido van Rossum4b8c6ea2000-02-04 15:39:30 +000032most popular way to do it, but there is another very different technique,
33that lets you have nearly all the advantages of multi-threading, without
34actually using multiple threads. it's really only practical if your program
35is largely I/O bound. If your program is CPU bound, then pre-emptive
36scheduled threads are probably what you really need. Network servers are
Tim Peters146965a2001-01-14 18:09:23 +000037rarely CPU-bound, however.
Guido van Rossum4b8c6ea2000-02-04 15:39:30 +000038
Tim Peters146965a2001-01-14 18:09:23 +000039If your operating system supports the select() system call in its I/O
Guido van Rossum4b8c6ea2000-02-04 15:39:30 +000040library (and nearly all do), then you can use it to juggle multiple
41communication channels at once; doing other work while your I/O is taking
42place in the "background." Although this strategy can seem strange and
43complex, especially at first, it is in many ways easier to understand and
44control than multi-threaded programming. The module documented here solves
45many of the difficult problems for you, making the task of building
Tim Peters146965a2001-01-14 18:09:23 +000046sophisticated high-performance network servers and clients a snap.
Guido van Rossum4b8c6ea2000-02-04 15:39:30 +000047"""
48
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +000049import exceptions
Guido van Rossum0039d7b1999-01-12 20:19:27 +000050import select
51import socket
Guido van Rossum0039d7b1999-01-12 20:19:27 +000052import sys
53
54import os
Jeremy Hyltona8b5f7d2001-08-10 14:30:35 +000055from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, \
Jeremy Hyltone16e54f2001-10-29 16:44:37 +000056 ENOTCONN, ESHUTDOWN, EINTR, EISCONN
Guido van Rossum0039d7b1999-01-12 20:19:27 +000057
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +000058try:
Fred Drake526a1822000-09-11 04:00:46 +000059 socket_map
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +000060except NameError:
Fred Drake526a1822000-09-11 04:00:46 +000061 socket_map = {}
Guido van Rossum0039d7b1999-01-12 20:19:27 +000062
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +000063class ExitNow (exceptions.Exception):
Fred Drake526a1822000-09-11 04:00:46 +000064 pass
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +000065
66DEBUG = 0
67
68def poll (timeout=0.0, map=None):
Fred Drake526a1822000-09-11 04:00:46 +000069 if map is None:
70 map = socket_map
71 if map:
72 r = []; w = []; e = []
73 for fd, obj in map.items():
74 if obj.readable():
75 r.append (fd)
76 if obj.writable():
77 w.append (fd)
Jeremy Hyltonfbd57972001-10-29 16:32:19 +000078 try:
79 r,w,e = select.select (r,w,e, timeout)
80 except select.error, err:
81 if err[0] != EINTR:
82 raise
Guido van Rossum0039d7b1999-01-12 20:19:27 +000083
Fred Drake526a1822000-09-11 04:00:46 +000084 if DEBUG:
85 print r,w,e
Guido van Rossum0039d7b1999-01-12 20:19:27 +000086
Fred Drake526a1822000-09-11 04:00:46 +000087 for fd in r:
88 try:
89 obj = map[fd]
Fred Drake526a1822000-09-11 04:00:46 +000090 except KeyError:
Martin v. Löwis6ec9a362001-10-09 10:10:33 +000091 continue
92
93 try:
94 obj.handle_read_event()
95 except ExitNow:
96 raise ExitNow
97 except:
98 obj.handle_error()
Guido van Rossum0039d7b1999-01-12 20:19:27 +000099
Fred Drake526a1822000-09-11 04:00:46 +0000100 for fd in w:
101 try:
102 obj = map[fd]
Fred Drake526a1822000-09-11 04:00:46 +0000103 except KeyError:
Martin v. Löwis6ec9a362001-10-09 10:10:33 +0000104 continue
105
106 try:
107 obj.handle_write_event()
108 except ExitNow:
109 raise ExitNow
110 except:
111 obj.handle_error()
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000112
113def poll2 (timeout=0.0, map=None):
Fred Drake526a1822000-09-11 04:00:46 +0000114 import poll
115 if map is None:
116 map=socket_map
Martin v. Löwisf6cc07c2001-09-19 17:31:47 +0000117 if timeout is not None:
118 # timeout is in milliseconds
119 timeout = int(timeout*1000)
Fred Drake526a1822000-09-11 04:00:46 +0000120 if map:
121 l = []
122 for fd, obj in map.items():
123 flags = 0
124 if obj.readable():
125 flags = poll.POLLIN
126 if obj.writable():
127 flags = flags | poll.POLLOUT
128 if flags:
129 l.append ((fd, flags))
130 r = poll.poll (l, timeout)
131 for fd, flags in r:
132 try:
133 obj = map[fd]
Fred Drake526a1822000-09-11 04:00:46 +0000134 except KeyError:
Martin v. Löwis6ec9a362001-10-09 10:10:33 +0000135 continue
136
137 try:
138 if (flags & poll.POLLIN):
139 obj.handle_read_event()
140 if (flags & poll.POLLOUT):
141 obj.handle_write_event()
142 except ExitNow:
143 raise ExitNow
144 except:
145 obj.handle_error()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000146
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000147def poll3 (timeout=0.0, map=None):
148 # Use the poll() support added to the select module in Python 2.0
149 if map is None:
150 map=socket_map
Martin v. Löwisf6cc07c2001-09-19 17:31:47 +0000151 if timeout is not None:
152 # timeout is in milliseconds
153 timeout = int(timeout*1000)
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000154 pollster = select.poll()
155 if map:
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000156 for fd, obj in map.items():
157 flags = 0
158 if obj.readable():
159 flags = select.POLLIN
160 if obj.writable():
161 flags = flags | select.POLLOUT
162 if flags:
163 pollster.register(fd, flags)
Jeremy Hyltonfbd57972001-10-29 16:32:19 +0000164 try:
165 r = pollster.poll (timeout)
166 except select.error, err:
167 if err[0] != EINTR:
168 raise
169 r = []
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000170 for fd, flags in r:
171 try:
172 obj = map[fd]
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000173 except KeyError:
Martin v. Löwis6ec9a362001-10-09 10:10:33 +0000174 continue
175
176 try:
177 if (flags & select.POLLIN):
178 obj.handle_read_event()
179 if (flags & select.POLLOUT):
180 obj.handle_write_event()
181 except ExitNow:
182 raise ExitNow
183 except:
184 obj.handle_error()
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000185
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000186def loop (timeout=30.0, use_poll=0, map=None):
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000187
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000188 if map is None:
189 map=socket_map
190
Fred Drake526a1822000-09-11 04:00:46 +0000191 if use_poll:
Andrew M. Kuchlingaf6963c2001-01-24 15:50:19 +0000192 if hasattr (select, 'poll'):
193 poll_fun = poll3
194 else:
195 poll_fun = poll2
Fred Drake526a1822000-09-11 04:00:46 +0000196 else:
197 poll_fun = poll
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000198
Fred Drake526a1822000-09-11 04:00:46 +0000199 while map:
200 poll_fun (timeout, map)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000201
202class dispatcher:
Fred Drake526a1822000-09-11 04:00:46 +0000203 debug = 0
204 connected = 0
205 accepting = 0
206 closing = 0
207 addr = None
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000208
Fred Drake526a1822000-09-11 04:00:46 +0000209 def __init__ (self, sock=None, map=None):
210 if sock:
211 self.set_socket (sock, map)
212 # I think it should inherit this anyway
213 self.socket.setblocking (0)
214 self.connected = 1
Andrew M. Kuchling4602c1b2001-10-03 17:07:25 +0000215 self.addr = sock.getpeername()
Jeremy Hyltonfbd57972001-10-29 16:32:19 +0000216 else:
217 self.socket = None
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000218
Fred Drake526a1822000-09-11 04:00:46 +0000219 def __repr__ (self):
Martin v. Löwis29103c72001-10-18 17:33:19 +0000220 status = [self.__class__.__module__+"."+self.__class__.__name__]
221 if self.accepting and self.addr:
222 status.append ('listening')
223 elif self.connected:
224 status.append ('connected')
225 if self.addr is not None:
226 try:
227 status.append ('%s:%d' % self.addr)
228 except TypeError:
229 status.append (repr(self.addr))
230 return '<%s at %#x>' % (' '.join (status), id (self))
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000231
Fred Drake526a1822000-09-11 04:00:46 +0000232 def add_channel (self, map=None):
233 #self.log_info ('adding channel %s' % self)
234 if map is None:
235 map=socket_map
236 map [self._fileno] = self
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000237
Fred Drake526a1822000-09-11 04:00:46 +0000238 def del_channel (self, map=None):
239 fd = self._fileno
240 if map is None:
241 map=socket_map
242 if map.has_key (fd):
243 #self.log_info ('closing channel %d:%s' % (fd, self))
244 del map [fd]
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000245
Fred Drake526a1822000-09-11 04:00:46 +0000246 def create_socket (self, family, type):
247 self.family_and_type = family, type
248 self.socket = socket.socket (family, type)
249 self.socket.setblocking(0)
250 self._fileno = self.socket.fileno()
251 self.add_channel()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000252
Fred Drake526a1822000-09-11 04:00:46 +0000253 def set_socket (self, sock, map=None):
Jeremy Hyltonfbd57972001-10-29 16:32:19 +0000254 self.socket = sock
255## self.__dict__['socket'] = sock
Fred Drake526a1822000-09-11 04:00:46 +0000256 self._fileno = sock.fileno()
257 self.add_channel (map)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000258
Fred Drake526a1822000-09-11 04:00:46 +0000259 def set_reuse_addr (self):
260 # try to re-use a server port if possible
261 try:
262 self.socket.setsockopt (
263 socket.SOL_SOCKET, socket.SO_REUSEADDR,
Jeremy Hyltona8b5f7d2001-08-10 14:30:35 +0000264 self.socket.getsockopt (socket.SOL_SOCKET,
265 socket.SO_REUSEADDR) | 1
Fred Drake526a1822000-09-11 04:00:46 +0000266 )
Fred Drake9f9b5932001-05-11 18:28:54 +0000267 except socket.error:
Fred Drake526a1822000-09-11 04:00:46 +0000268 pass
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000269
Fred Drake526a1822000-09-11 04:00:46 +0000270 # ==================================================
271 # predicates for select()
272 # these are used as filters for the lists of sockets
273 # to pass to select().
274 # ==================================================
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000275
Fred Drake526a1822000-09-11 04:00:46 +0000276 def readable (self):
277 return 1
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000278
Fred Drake526a1822000-09-11 04:00:46 +0000279 if os.name == 'mac':
280 # The macintosh will select a listening socket for
281 # write if you let it. What might this mean?
282 def writable (self):
283 return not self.accepting
284 else:
285 def writable (self):
286 return 1
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000287
Fred Drake526a1822000-09-11 04:00:46 +0000288 # ==================================================
289 # socket object methods.
290 # ==================================================
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000291
Fred Drake526a1822000-09-11 04:00:46 +0000292 def listen (self, num):
293 self.accepting = 1
294 if os.name == 'nt' and num > 5:
295 num = 1
296 return self.socket.listen (num)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000297
Fred Drake526a1822000-09-11 04:00:46 +0000298 def bind (self, addr):
299 self.addr = addr
300 return self.socket.bind (addr)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000301
Fred Drake526a1822000-09-11 04:00:46 +0000302 def connect (self, address):
303 self.connected = 0
Jeremy Hyltone16e54f2001-10-29 16:44:37 +0000304 err = self.socket.connect_ex(address)
305 if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
306 return
307 if err in (0, EISCONN):
308 self.addr = address
309 self.connected = 1
310 self.handle_connect()
311 raise socket.error, err
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000312
Fred Drake526a1822000-09-11 04:00:46 +0000313 def accept (self):
314 try:
315 conn, addr = self.socket.accept()
316 return conn, addr
317 except socket.error, why:
318 if why[0] == EWOULDBLOCK:
319 pass
320 else:
321 raise socket.error, why
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000322
Fred Drake526a1822000-09-11 04:00:46 +0000323 def send (self, data):
324 try:
325 result = self.socket.send (data)
326 return result
327 except socket.error, why:
328 if why[0] == EWOULDBLOCK:
329 return 0
330 else:
331 raise socket.error, why
332 return 0
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000333
Fred Drake526a1822000-09-11 04:00:46 +0000334 def recv (self, buffer_size):
335 try:
336 data = self.socket.recv (buffer_size)
337 if not data:
338 # a closed connection is indicated by signaling
339 # a read condition, and having recv() return 0.
340 self.handle_close()
341 return ''
342 else:
343 return data
344 except socket.error, why:
345 # winsock sometimes throws ENOTCONN
346 if why[0] in [ECONNRESET, ENOTCONN, ESHUTDOWN]:
347 self.handle_close()
348 return ''
349 else:
350 raise socket.error, why
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000351
Fred Drake526a1822000-09-11 04:00:46 +0000352 def close (self):
353 self.del_channel()
354 self.socket.close()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000355
Fred Drake526a1822000-09-11 04:00:46 +0000356 # cheap inheritance, used to pass all other attribute
357 # references to the underlying socket object.
358 def __getattr__ (self, attr):
359 return getattr (self.socket, attr)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000360
Fred Drake526a1822000-09-11 04:00:46 +0000361 # log and log_info maybe overriden to provide more sophisitcated
362 # logging and warning methods. In general, log is for 'hit' logging
Tim Peters146965a2001-01-14 18:09:23 +0000363 # and 'log_info' is for informational, warning and error logging.
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000364
Fred Drake526a1822000-09-11 04:00:46 +0000365 def log (self, message):
366 sys.stderr.write ('log: %s\n' % str(message))
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000367
Fred Drake526a1822000-09-11 04:00:46 +0000368 def log_info (self, message, type='info'):
369 if __debug__ or type != 'info':
370 print '%s: %s' % (type, message)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000371
Fred Drake526a1822000-09-11 04:00:46 +0000372 def handle_read_event (self):
373 if self.accepting:
374 # for an accepting socket, getting a read implies
375 # that we are connected
376 if not self.connected:
377 self.connected = 1
378 self.handle_accept()
379 elif not self.connected:
380 self.handle_connect()
381 self.connected = 1
382 self.handle_read()
383 else:
384 self.handle_read()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000385
Fred Drake526a1822000-09-11 04:00:46 +0000386 def handle_write_event (self):
387 # getting a write implies that we are connected
388 if not self.connected:
389 self.handle_connect()
390 self.connected = 1
391 self.handle_write()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000392
Fred Drake526a1822000-09-11 04:00:46 +0000393 def handle_expt_event (self):
394 self.handle_expt()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000395
Fred Drake526a1822000-09-11 04:00:46 +0000396 def handle_error (self):
Jeremy Hyltona8b5f7d2001-08-10 14:30:35 +0000397 nil, t, v, tbinfo = compact_traceback()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000398
Fred Drake526a1822000-09-11 04:00:46 +0000399 # sometimes a user repr method will crash.
400 try:
401 self_repr = repr (self)
402 except:
403 self_repr = '<__repr__ (self) failed for object at %0x>' % id(self)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000404
Fred Drake526a1822000-09-11 04:00:46 +0000405 self.log_info (
406 'uncaptured python exception, closing channel %s (%s:%s %s)' % (
407 self_repr,
408 t,
409 v,
410 tbinfo
411 ),
412 'error'
413 )
414 self.close()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000415
Fred Drake526a1822000-09-11 04:00:46 +0000416 def handle_expt (self):
417 self.log_info ('unhandled exception', 'warning')
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000418
Fred Drake526a1822000-09-11 04:00:46 +0000419 def handle_read (self):
420 self.log_info ('unhandled read event', 'warning')
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000421
Fred Drake526a1822000-09-11 04:00:46 +0000422 def handle_write (self):
423 self.log_info ('unhandled write event', 'warning')
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000424
Fred Drake526a1822000-09-11 04:00:46 +0000425 def handle_connect (self):
426 self.log_info ('unhandled connect event', 'warning')
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000427
Fred Drake526a1822000-09-11 04:00:46 +0000428 def handle_accept (self):
429 self.log_info ('unhandled accept event', 'warning')
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000430
Fred Drake526a1822000-09-11 04:00:46 +0000431 def handle_close (self):
432 self.log_info ('unhandled close event', 'warning')
433 self.close()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000434
435# ---------------------------------------------------------------------------
436# adds simple buffered output capability, useful for simple clients.
437# [for more sophisticated usage use asynchat.async_chat]
438# ---------------------------------------------------------------------------
439
440class dispatcher_with_send (dispatcher):
Fred Drake526a1822000-09-11 04:00:46 +0000441 def __init__ (self, sock=None):
442 dispatcher.__init__ (self, sock)
443 self.out_buffer = ''
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000444
Fred Drake526a1822000-09-11 04:00:46 +0000445 def initiate_send (self):
446 num_sent = 0
447 num_sent = dispatcher.send (self, self.out_buffer[:512])
448 self.out_buffer = self.out_buffer[num_sent:]
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000449
Fred Drake526a1822000-09-11 04:00:46 +0000450 def handle_write (self):
451 self.initiate_send()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000452
Fred Drake526a1822000-09-11 04:00:46 +0000453 def writable (self):
454 return (not self.connected) or len(self.out_buffer)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000455
Fred Drake526a1822000-09-11 04:00:46 +0000456 def send (self, data):
457 if self.debug:
458 self.log_info ('sending %s' % repr(data))
459 self.out_buffer = self.out_buffer + data
460 self.initiate_send()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000461
462# ---------------------------------------------------------------------------
463# used for debugging.
464# ---------------------------------------------------------------------------
465
Guido van Rossuma8d0f4f1999-06-08 13:20:05 +0000466def compact_traceback ():
Fred Drake526a1822000-09-11 04:00:46 +0000467 t,v,tb = sys.exc_info()
468 tbinfo = []
469 while 1:
470 tbinfo.append ((
471 tb.tb_frame.f_code.co_filename,
Tim Peters146965a2001-01-14 18:09:23 +0000472 tb.tb_frame.f_code.co_name,
Fred Drake526a1822000-09-11 04:00:46 +0000473 str(tb.tb_lineno)
474 ))
475 tb = tb.tb_next
476 if not tb:
477 break
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000478
Fred Drake526a1822000-09-11 04:00:46 +0000479 # just to be safe
480 del tb
Guido van Rossuma8d0f4f1999-06-08 13:20:05 +0000481
Fred Drake526a1822000-09-11 04:00:46 +0000482 file, function, line = tbinfo[-1]
Eric S. Raymondb49f4a42001-02-09 05:07:04 +0000483 info = '[' + '] ['.join(map(lambda x: '|'.join(x), tbinfo)) + ']'
Fred Drake526a1822000-09-11 04:00:46 +0000484 return (file, function, line), t, v, info
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000485
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000486def close_all (map=None):
Fred Drake526a1822000-09-11 04:00:46 +0000487 if map is None:
488 map=socket_map
489 for x in map.values():
490 x.socket.close()
491 map.clear()
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000492
493# Asynchronous File I/O:
494#
495# After a little research (reading man pages on various unixen, and
496# digging through the linux kernel), I've determined that select()
497# isn't meant for doing doing asynchronous file i/o.
498# Heartening, though - reading linux/mm/filemap.c shows that linux
499# supports asynchronous read-ahead. So _MOST_ of the time, the data
500# will be sitting in memory for us already when we go to read it.
501#
502# What other OS's (besides NT) support async file i/o? [VMS?]
503#
504# Regardless, this is useful for pipes, and stdin/stdout...
505
506import os
507if os.name == 'posix':
Fred Drake526a1822000-09-11 04:00:46 +0000508 import fcntl
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000509
Fred Drake526a1822000-09-11 04:00:46 +0000510 class file_wrapper:
511 # here we override just enough to make a file
512 # look like a socket for the purposes of asyncore.
513 def __init__ (self, fd):
514 self.fd = fd
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000515
Fred Drake526a1822000-09-11 04:00:46 +0000516 def recv (self, *args):
517 return apply (os.read, (self.fd,)+args)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000518
Fred Drake526a1822000-09-11 04:00:46 +0000519 def send (self, *args):
520 return apply (os.write, (self.fd,)+args)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000521
Fred Drake526a1822000-09-11 04:00:46 +0000522 read = recv
523 write = send
Andrew M. Kuchlingda85a272000-09-08 20:30:39 +0000524
Fred Drake526a1822000-09-11 04:00:46 +0000525 def close (self):
526 return os.close (self.fd)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000527
Fred Drake526a1822000-09-11 04:00:46 +0000528 def fileno (self):
529 return self.fd
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000530
Fred Drake526a1822000-09-11 04:00:46 +0000531 class file_dispatcher (dispatcher):
532 def __init__ (self, fd):
533 dispatcher.__init__ (self)
534 self.connected = 1
535 # set it to non-blocking mode
Fred Drakea94414a2001-05-10 15:33:31 +0000536 flags = fcntl.fcntl (fd, fcntl.F_GETFL, 0)
537 flags = flags | os.O_NONBLOCK
538 fcntl.fcntl (fd, fcntl.F_SETFL, flags)
Fred Drake526a1822000-09-11 04:00:46 +0000539 self.set_file (fd)
Guido van Rossum0039d7b1999-01-12 20:19:27 +0000540
Fred Drake526a1822000-09-11 04:00:46 +0000541 def set_file (self, fd):
542 self._fileno = fd
543 self.socket = file_wrapper (fd)
544 self.add_channel()