| 1 |
#! /usr/bin/env python |
| 2 |
# |
| 3 |
# (C) 2001-2015 Chris Liechti <[email protected]> |
| 4 |
# |
| 5 |
# SPDX-License-Identifier: BSD-3-Clause |
| 6 |
"""\ |
| 7 |
Multi-port serial<->TCP/IP forwarder. |
| 8 |
- RFC 2217 |
| 9 |
- check existence of serial port periodically |
| 10 |
- start/stop forwarders |
| 11 |
- each forwarder creates a server socket and opens the serial port |
| 12 |
- serial ports are opened only once. network connect/disconnect |
| 13 |
does not influence serial port |
| 14 |
- only one client per connection |
| 15 |
""" |
| 16 |
import os |
| 17 |
import select |
| 18 |
import socket |
| 19 |
import sys |
| 20 |
import time |
| 21 |
import traceback |
| 22 |
|
| 23 |
import serial |
| 24 |
import serial.rfc2217 |
| 25 |
import serial.tools.list_ports |
| 26 |
|
| 27 |
import dbus |
| 28 |
|
| 29 |
# Try to import the avahi service definitions properly. If the avahi module is |
| 30 |
# not available, fall back to a hard-coded solution that hopefully still works. |
| 31 |
try: |
| 32 |
import avahi |
| 33 |
except ImportError: |
| 34 |
class avahi: |
| 35 |
DBUS_NAME = "org.freedesktop.Avahi" |
| 36 |
DBUS_PATH_SERVER = "/" |
| 37 |
DBUS_INTERFACE_SERVER = "org.freedesktop.Avahi.Server" |
| 38 |
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup" |
| 39 |
IF_UNSPEC = -1 |
| 40 |
PROTO_UNSPEC, PROTO_INET, PROTO_INET6 = -1, 0, 1 |
| 41 |
|
| 42 |
|
| 43 |
class ZeroconfService: |
| 44 |
"""\ |
| 45 |
A simple class to publish a network service with zeroconf using avahi. |
| 46 |
""" |
| 47 |
|
| 48 |
def __init__(self, name, port, stype="_http._tcp", |
| 49 |
domain="", host="", text=""): |
| 50 |
self.name = name |
| 51 |
self.stype = stype |
| 52 |
self.domain = domain |
| 53 |
self.host = host |
| 54 |
self.port = port |
| 55 |
self.text = text |
| 56 |
self.group = None |
| 57 |
|
| 58 |
def publish(self): |
| 59 |
bus = dbus.SystemBus() |
| 60 |
server = dbus.Interface( |
| 61 |
bus.get_object( |
| 62 |
avahi.DBUS_NAME, |
| 63 |
avahi.DBUS_PATH_SERVER |
| 64 |
), |
| 65 |
avahi.DBUS_INTERFACE_SERVER |
| 66 |
) |
| 67 |
|
| 68 |
g = dbus.Interface( |
| 69 |
bus.get_object( |
| 70 |
avahi.DBUS_NAME, |
| 71 |
server.EntryGroupNew() |
| 72 |
), |
| 73 |
avahi.DBUS_INTERFACE_ENTRY_GROUP |
| 74 |
) |
| 75 |
|
| 76 |
g.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32(0), |
| 77 |
self.name, self.stype, self.domain, self.host, |
| 78 |
dbus.UInt16(self.port), self.text) |
| 79 |
|
| 80 |
g.Commit() |
| 81 |
self.group = g |
| 82 |
|
| 83 |
def unpublish(self): |
| 84 |
if self.group is not None: |
| 85 |
self.group.Reset() |
| 86 |
self.group = None |
| 87 |
|
| 88 |
def __str__(self): |
| 89 |
return "{!r} @ {}:{} ({})".format(self.name, self.host, self.port, self.stype) |
| 90 |
|
| 91 |
|
| 92 |
class Forwarder(ZeroconfService): |
| 93 |
"""\ |
| 94 |
Single port serial<->TCP/IP forarder that depends on an external select |
| 95 |
loop. |
| 96 |
- Buffers for serial -> network and network -> serial |
| 97 |
- RFC 2217 state |
| 98 |
- Zeroconf publish/unpublish on open/close. |
| 99 |
""" |
| 100 |
|
| 101 |
def __init__(self, device, name, network_port, on_close=None, log=None): |
| 102 |
ZeroconfService.__init__(self, name, network_port, stype='_serial_port._tcp') |
| 103 |
self.alive = False |
| 104 |
self.network_port = network_port |
| 105 |
self.on_close = on_close |
| 106 |
self.log = log |
| 107 |
self.device = device |
| 108 |
self.serial = serial.Serial() |
| 109 |
self.serial.port = device |
| 110 |
self.serial.baudrate = 115200 |
| 111 |
self.serial.timeout = 0 |
| 112 |
self.socket = None |
| 113 |
self.server_socket = None |
| 114 |
self.rfc2217 = None # instantiate later, when connecting |
| 115 |
|
| 116 |
def __del__(self): |
| 117 |
try: |
| 118 |
if self.alive: |
| 119 |
self.close() |
| 120 |
except: |
| 121 |
pass # XXX errors on shutdown |
| 122 |
|
| 123 |
def open(self): |
| 124 |
"""open serial port, start network server and publish service""" |
| 125 |
self.buffer_net2ser = bytearray() |
| 126 |
self.buffer_ser2net = bytearray() |
| 127 |
|
| 128 |
# open serial port |
| 129 |
try: |
| 130 |
self.serial.rts = False |
| 131 |
self.serial.open() |
| 132 |
except Exception as msg: |
| 133 |
self.handle_serial_error(msg) |
| 134 |
|
| 135 |
self.serial_settings_backup = self.serial.get_settings() |
| 136 |
|
| 137 |
# start the socket server |
| 138 |
# XXX add IPv6 support: use getaddrinfo for socket options, bind to multiple sockets? |
| 139 |
# info_list = socket.getaddrinfo(None, port, 0, socket.SOCK_STREAM, 0, socket.AI_PASSIVE) |
| 140 |
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| 141 |
self.server_socket.setsockopt( |
| 142 |
socket.SOL_SOCKET, |
| 143 |
socket.SO_REUSEADDR, |
| 144 |
self.server_socket.getsockopt( |
| 145 |
socket.SOL_SOCKET, |
| 146 |
socket.SO_REUSEADDR |
| 147 |
) | 1 |
| 148 |
) |
| 149 |
self.server_socket.setblocking(0) |
| 150 |
try: |
| 151 |
self.server_socket.bind(('', self.network_port)) |
| 152 |
self.server_socket.listen(1) |
| 153 |
except socket.error as msg: |
| 154 |
self.handle_server_error() |
| 155 |
#~ raise |
| 156 |
if self.log is not None: |
| 157 |
self.log.info("{}: Waiting for connection on {}...".format(self.device, self.network_port)) |
| 158 |
|
| 159 |
# zeroconfig |
| 160 |
self.publish() |
| 161 |
|
| 162 |
# now we are ready |
| 163 |
self.alive = True |
| 164 |
|
| 165 |
def close(self): |
| 166 |
"""Close all resources and unpublish service""" |
| 167 |
if self.log is not None: |
| 168 |
self.log.info("{}: closing...".format(self.device)) |
| 169 |
self.alive = False |
| 170 |
self.unpublish() |
| 171 |
if self.server_socket: |
| 172 |
self.server_socket.close() |
| 173 |
if self.socket: |
| 174 |
self.handle_disconnect() |
| 175 |
self.serial.close() |
| 176 |
if self.on_close is not None: |
| 177 |
# ensure it is only called once |
| 178 |
callback = self.on_close |
| 179 |
self.on_close = None |
| 180 |
callback(self) |
| 181 |
|
| 182 |
def write(self, data): |
| 183 |
"""the write method is used by serial.rfc2217.PortManager. it has to |
| 184 |
write to the network.""" |
| 185 |
self.buffer_ser2net += data |
| 186 |
|
| 187 |
def update_select_maps(self, read_map, write_map, error_map): |
| 188 |
"""Update dictionaries for select call. insert fd->callback mapping""" |
| 189 |
if self.alive: |
| 190 |
# always handle serial port reads |
| 191 |
read_map[self.serial] = self.handle_serial_read |
| 192 |
error_map[self.serial] = self.handle_serial_error |
| 193 |
# handle serial port writes if buffer is not empty |
| 194 |
if self.buffer_net2ser: |
| 195 |
write_map[self.serial] = self.handle_serial_write |
| 196 |
# handle network |
| 197 |
if self.socket is not None: |
| 198 |
# handle socket if connected |
| 199 |
# only read from network if the internal buffer is not |
| 200 |
# already filled. the TCP flow control will hold back data |
| 201 |
if len(self.buffer_net2ser) < 2048: |
| 202 |
read_map[self.socket] = self.handle_socket_read |
| 203 |
# only check for write readiness when there is data |
| 204 |
if self.buffer_ser2net: |
| 205 |
write_map[self.socket] = self.handle_socket_write |
| 206 |
error_map[self.socket] = self.handle_socket_error |
| 207 |
else: |
| 208 |
# no connection, ensure clear buffer |
| 209 |
self.buffer_ser2net = bytearray() |
| 210 |
# check the server socket |
| 211 |
read_map[self.server_socket] = self.handle_connect |
| 212 |
error_map[self.server_socket] = self.handle_server_error |
| 213 |
|
| 214 |
def handle_serial_read(self): |
| 215 |
"""Reading from serial port""" |
| 216 |
try: |
| 217 |
data = os.read(self.serial.fileno(), 1024) |
| 218 |
if data: |
| 219 |
# store data in buffer if there is a client connected |
| 220 |
if self.socket is not None: |
| 221 |
# escape outgoing data when needed (Telnet IAC (0xff) character) |
| 222 |
if self.rfc2217: |
| 223 |
data = serial.to_bytes(self.rfc2217.escape(data)) |
| 224 |
self.buffer_ser2net.extend(data) |
| 225 |
else: |
| 226 |
self.handle_serial_error() |
| 227 |
except Exception as msg: |
| 228 |
self.handle_serial_error(msg) |
| 229 |
|
| 230 |
def handle_serial_write(self): |
| 231 |
"""Writing to serial port""" |
| 232 |
try: |
| 233 |
# write a chunk |
| 234 |
n = os.write(self.serial.fileno(), bytes(self.buffer_net2ser)) |
| 235 |
# and see how large that chunk was, remove that from buffer |
| 236 |
self.buffer_net2ser = self.buffer_net2ser[n:] |
| 237 |
except Exception as msg: |
| 238 |
self.handle_serial_error(msg) |
| 239 |
|
| 240 |
def handle_serial_error(self, error=None): |
| 241 |
"""Serial port error""" |
| 242 |
# terminate connection |
| 243 |
self.close() |
| 244 |
|
| 245 |
def handle_socket_read(self): |
| 246 |
"""Read from socket""" |
| 247 |
try: |
| 248 |
# read a chunk from the serial port |
| 249 |
data = self.socket.recv(1024) |
| 250 |
if data: |
| 251 |
# Process RFC 2217 stuff when enabled |
| 252 |
if self.rfc2217: |
| 253 |
data = b''.join(self.rfc2217.filter(data)) |
| 254 |
# add data to buffer |
| 255 |
self.buffer_net2ser.extend(data) |
| 256 |
else: |
| 257 |
# empty read indicates disconnection |
| 258 |
self.handle_disconnect() |
| 259 |
except socket.error: |
| 260 |
if self.log is not None: |
| 261 |
self.log.exception("{}: error reading...".format(self.device)) |
| 262 |
self.handle_socket_error() |
| 263 |
|
| 264 |
def handle_socket_write(self): |
| 265 |
"""Write to socket""" |
| 266 |
try: |
| 267 |
# write a chunk |
| 268 |
count = self.socket.send(bytes(self.buffer_ser2net)) |
| 269 |
# and remove the sent data from the buffer |
| 270 |
self.buffer_ser2net = self.buffer_ser2net[count:] |
| 271 |
except socket.error: |
| 272 |
if self.log is not None: |
| 273 |
self.log.exception("{}: error writing...".format(self.device)) |
| 274 |
self.handle_socket_error() |
| 275 |
|
| 276 |
def handle_socket_error(self): |
| 277 |
"""Socket connection fails""" |
| 278 |
self.handle_disconnect() |
| 279 |
|
| 280 |
def handle_connect(self): |
| 281 |
"""Server socket gets a connection""" |
| 282 |
# accept a connection in any case, close connection |
| 283 |
# below if already busy |
| 284 |
connection, addr = self.server_socket.accept() |
| 285 |
if self.socket is None: |
| 286 |
self.socket = connection |
| 287 |
# More quickly detect bad clients who quit without closing the |
| 288 |
# connection: After 1 second of idle, start sending TCP keep-alive |
| 289 |
# packets every 1 second. If 3 consecutive keep-alive packets |
| 290 |
# fail, assume the client is gone and close the connection. |
| 291 |
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) |
| 292 |
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 1) |
| 293 |
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 1) |
| 294 |
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 3) |
| 295 |
self.socket.setblocking(0) |
| 296 |
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) |
| 297 |
if self.log is not None: |
| 298 |
self.log.warning('{}: Connected by {}:{}'.format(self.device, addr[0], addr[1])) |
| 299 |
self.serial.rts = True |
| 300 |
self.serial.dtr = True |
| 301 |
if self.log is not None: |
| 302 |
self.rfc2217 = serial.rfc2217.PortManager(self.serial, self, logger=log.getChild(self.device)) |
| 303 |
else: |
| 304 |
self.rfc2217 = serial.rfc2217.PortManager(self.serial, self) |
| 305 |
else: |
| 306 |
# reject connection if there is already one |
| 307 |
connection.close() |
| 308 |
if self.log is not None: |
| 309 |
self.log.warning('{}: Rejecting connect from {}:{}'.format(self.device, addr[0], addr[1])) |
| 310 |
|
| 311 |
def handle_server_error(self): |
| 312 |
"""Socket server fails""" |
| 313 |
self.close() |
| 314 |
|
| 315 |
def handle_disconnect(self): |
| 316 |
"""Socket gets disconnected""" |
| 317 |
# signal disconnected terminal with control lines |
| 318 |
try: |
| 319 |
self.serial.rts = False |
| 320 |
self.serial.dtr = False |
| 321 |
finally: |
| 322 |
# restore original port configuration in case it was changed |
| 323 |
self.serial.apply_settings(self.serial_settings_backup) |
| 324 |
# stop RFC 2217 state machine |
| 325 |
self.rfc2217 = None |
| 326 |
# clear send buffer |
| 327 |
self.buffer_ser2net = bytearray() |
| 328 |
# close network connection |
| 329 |
if self.socket is not None: |
| 330 |
self.socket.close() |
| 331 |
self.socket = None |
| 332 |
if self.log is not None: |
| 333 |
self.log.warning('{}: Disconnected'.format(self.device)) |
| 334 |
|
| 335 |
|
| 336 |
def test(): |
| 337 |
service = ZeroconfService(name="TestService", port=3000) |
| 338 |
service.publish() |
| 339 |
input("Press the ENTER key to unpublish the service ") |
| 340 |
service.unpublish() |
| 341 |
|
| 342 |
|
| 343 |
if __name__ == '__main__': # noqa |
| 344 |
import logging |
| 345 |
import argparse |
| 346 |
|
| 347 |
VERBOSTIY = [ |
| 348 |
logging.ERROR, # 0 |
| 349 |
logging.WARNING, # 1 (default) |
| 350 |
logging.INFO, # 2 |
| 351 |
logging.DEBUG, # 3 |
| 352 |
] |
| 353 |
|
| 354 |
parser = argparse.ArgumentParser( |
| 355 |
usage="""\ |
| 356 |
%(prog)s [options] |
| 357 |
|
| 358 |
Announce the existence of devices using zeroconf and provide |
| 359 |
a TCP/IP <-> serial port gateway (implements RFC 2217). |
| 360 |
|
| 361 |
If running as daemon, write to syslog. Otherwise write to stdout. |
| 362 |
""", |
| 363 |
epilog="""\ |
| 364 |
NOTE: no security measures are implemented. Anyone can remotely connect |
| 365 |
to this service over the network. |
| 366 |
|
| 367 |
Only one connection at once, per port, is supported. When the connection is |
| 368 |
terminated, it waits for the next connect. |
| 369 |
""") |
| 370 |
|
| 371 |
group = parser.add_argument_group("serial port settings") |
| 372 |
|
| 373 |
group.add_argument( |
| 374 |
"--ports-regex", |
| 375 |
help="specify a regex to search against the serial devices and their descriptions (default: %(default)s)", |
| 376 |
default='/dev/ttyUSB[0-9]+', |
| 377 |
metavar="REGEX") |
| 378 |
|
| 379 |
group = parser.add_argument_group("network settings") |
| 380 |
|
| 381 |
group.add_argument( |
| 382 |
"--tcp-port", |
| 383 |
dest="base_port", |
| 384 |
help="specify lowest TCP port number (default: %(default)s)", |
| 385 |
default=7000, |
| 386 |
type=int, |
| 387 |
metavar="PORT") |
| 388 |
|
| 389 |
group = parser.add_argument_group("daemon") |
| 390 |
|
| 391 |
group.add_argument( |
| 392 |
"-d", "--daemon", |
| 393 |
dest="daemonize", |
| 394 |
action="store_true", |
| 395 |
help="start as daemon", |
| 396 |
default=False) |
| 397 |
|
| 398 |
group.add_argument( |
| 399 |
"--pidfile", |
| 400 |
help="specify a name for the PID file", |
| 401 |
default=None, |
| 402 |
metavar="FILE") |
| 403 |
|
| 404 |
group = parser.add_argument_group("diagnostics") |
| 405 |
|
| 406 |
group.add_argument( |
| 407 |
"-o", "--logfile", |
| 408 |
help="write messages file instead of stdout", |
| 409 |
default=None, |
| 410 |
metavar="FILE") |
| 411 |
|
| 412 |
group.add_argument( |
| 413 |
"-q", "--quiet", |
| 414 |
dest="verbosity", |
| 415 |
action="store_const", |
| 416 |
const=0, |
| 417 |
help="suppress most diagnostic messages", |
| 418 |
default=1) |
| 419 |
|
| 420 |
group.add_argument( |
| 421 |
"-v", "--verbose", |
| 422 |
dest="verbosity", |
| 423 |
action="count", |
| 424 |
help="increase diagnostic messages") |
| 425 |
|
| 426 |
args = parser.parse_args() |
| 427 |
|
| 428 |
# set up logging |
| 429 |
logging.basicConfig(level=VERBOSTIY[min(args.verbosity, len(VERBOSTIY) - 1)]) |
| 430 |
log = logging.getLogger('port_publisher') |
| 431 |
|
| 432 |
# redirect output if specified |
| 433 |
if args.logfile is not None: |
| 434 |
class WriteFlushed: |
| 435 |
def __init__(self, fileobj): |
| 436 |
self.fileobj = fileobj |
| 437 |
|
| 438 |
def write(self, s): |
| 439 |
self.fileobj.write(s) |
| 440 |
self.fileobj.flush() |
| 441 |
|
| 442 |
def close(self): |
| 443 |
self.fileobj.close() |
| 444 |
sys.stdout = sys.stderr = WriteFlushed(open(args.logfile, 'a')) |
| 445 |
# atexit.register(lambda: sys.stdout.close()) |
| 446 |
|
| 447 |
if args.daemonize: |
| 448 |
# if running as daemon is requested, do the fork magic |
| 449 |
# args.quiet = True |
| 450 |
# do the UNIX double-fork magic, see Stevens' "Advanced |
| 451 |
# Programming in the UNIX Environment" for details (ISBN 0201563177) |
| 452 |
try: |
| 453 |
pid = os.fork() |
| 454 |
if pid > 0: |
| 455 |
# exit first parent |
| 456 |
sys.exit(0) |
| 457 |
except OSError as e: |
| 458 |
log.critical("fork #1 failed: {} ({})\n".format(e.errno, e.strerror)) |
| 459 |
sys.exit(1) |
| 460 |
|
| 461 |
# decouple from parent environment |
| 462 |
os.chdir("/") # don't prevent unmounting.... |
| 463 |
os.setsid() |
| 464 |
os.umask(0) |
| 465 |
|
| 466 |
# do second fork |
| 467 |
try: |
| 468 |
pid = os.fork() |
| 469 |
if pid > 0: |
| 470 |
# exit from second parent, save eventual PID before |
| 471 |
if args.pidfile is not None: |
| 472 |
open(args.pidfile, 'w').write("{}".format(pid)) |
| 473 |
sys.exit(0) |
| 474 |
except OSError as e: |
| 475 |
log.critical("fork #2 failed: {} ({})\n".format(e.errno, e.strerror)) |
| 476 |
sys.exit(1) |
| 477 |
|
| 478 |
if args.logfile is None: |
| 479 |
import syslog |
| 480 |
syslog.openlog("serial port publisher") |
| 481 |
|
| 482 |
# redirect output to syslog |
| 483 |
class WriteToSysLog: |
| 484 |
def __init__(self): |
| 485 |
self.buffer = '' |
| 486 |
|
| 487 |
def write(self, s): |
| 488 |
self.buffer += s |
| 489 |
if '\n' in self.buffer: |
| 490 |
output, self.buffer = self.buffer.split('\n', 1) |
| 491 |
syslog.syslog(output) |
| 492 |
|
| 493 |
def flush(self): |
| 494 |
syslog.syslog(self.buffer) |
| 495 |
self.buffer = '' |
| 496 |
|
| 497 |
def close(self): |
| 498 |
self.flush() |
| 499 |
sys.stdout = sys.stderr = WriteToSysLog() |
| 500 |
|
| 501 |
# ensure the that the daemon runs a normal user, if run as root |
| 502 |
# if os.getuid() == 0: |
| 503 |
# name, passwd, uid, gid, desc, home, shell = pwd.getpwnam('someuser') |
| 504 |
# os.setgid(gid) # set group first |
| 505 |
# os.setuid(uid) # set user |
| 506 |
|
| 507 |
# keep the published stuff in a dictionary |
| 508 |
published = {} |
| 509 |
# get a nice hostname |
| 510 |
hostname = socket.gethostname() |
| 511 |
|
| 512 |
def unpublish(forwarder): |
| 513 |
"""when forwarders die, we need to unregister them""" |
| 514 |
try: |
| 515 |
del published[forwarder.device] |
| 516 |
except KeyError: |
| 517 |
pass |
| 518 |
else: |
| 519 |
log.info("unpublish: {}".format(forwarder)) |
| 520 |
|
| 521 |
alive = True |
| 522 |
next_check = 0 |
| 523 |
# main loop |
| 524 |
while alive: |
| 525 |
try: |
| 526 |
# if it is time, check for serial port devices |
| 527 |
now = time.time() |
| 528 |
if now > next_check: |
| 529 |
next_check = now + 5 |
| 530 |
connected = [d for d, p, i in serial.tools.list_ports.grep(args.ports_regex)] |
| 531 |
# Handle devices that are published, but no longer connected |
| 532 |
for device in set(published).difference(connected): |
| 533 |
log.info("unpublish: {}".format(published[device])) |
| 534 |
unpublish(published[device]) |
| 535 |
# Handle devices that are connected but not yet published |
| 536 |
for device in sorted(set(connected).difference(published)): |
| 537 |
# Find the first available port, starting from specified number |
| 538 |
port = args.base_port |
| 539 |
ports_in_use = [f.network_port for f in published.values()] |
| 540 |
while port in ports_in_use: |
| 541 |
port += 1 |
| 542 |
published[device] = Forwarder( |
| 543 |
device, |
| 544 |
"{} on {}".format(device, hostname), |
| 545 |
port, |
| 546 |
on_close=unpublish, |
| 547 |
log=log) |
| 548 |
log.warning("publish: {}".format(published[device])) |
| 549 |
published[device].open() |
| 550 |
|
| 551 |
# select_start = time.time() |
| 552 |
read_map = {} |
| 553 |
write_map = {} |
| 554 |
error_map = {} |
| 555 |
for publisher in published.values(): |
| 556 |
publisher.update_select_maps(read_map, write_map, error_map) |
| 557 |
readers, writers, errors = select.select( |
| 558 |
read_map.keys(), |
| 559 |
write_map.keys(), |
| 560 |
error_map.keys(), |
| 561 |
5) |
| 562 |
# select_end = time.time() |
| 563 |
# print "select used %.3f s" % (select_end - select_start) |
| 564 |
for reader in readers: |
| 565 |
read_map[reader]() |
| 566 |
for writer in writers: |
| 567 |
write_map[writer]() |
| 568 |
for error in errors: |
| 569 |
error_map[error]() |
| 570 |
# print "operation used %.3f s" % (time.time() - select_end) |
| 571 |
except KeyboardInterrupt: |
| 572 |
alive = False |
| 573 |
sys.stdout.write('\n') |
| 574 |
except SystemExit: |
| 575 |
raise |
| 576 |
except: |
| 577 |
#~ raise |
| 578 |
traceback.print_exc() |