chiark - git - mdw - tripe/blob - svc/watch.in

   1 #! @PYTHON@
   2 ### -*-python-*-
   3 ###
   4 ### Watch arrival and departure of peers
   5 ###
   6 ### (c) 2007 Straylight/Edgeware
   7 ###
   8
   9 ###----- Licensing notice ---------------------------------------------------
  10 ###
  11 ### This file is part of Trivial IP Encryption (TrIPE).
  12 ###
  13 ### TrIPE is free software; you can redistribute it and/or modify
  14 ### it under the terms of the GNU General Public License as published by
  15 ### the Free Software Foundation; either version 2 of the License, or
  16 ### (at your option) any later version.
  17 ###
  18 ### TrIPE is distributed in the hope that it will be useful,
  19 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ### GNU General Public License for more details.
  22 ###
  23 ### You should have received a copy of the GNU General Public License
  24 ### along with TrIPE; if not, write to the Free Software Foundation,
  25 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 VERSION = '@VERSION@'
  28
  29 ###--------------------------------------------------------------------------
  30 ### External dependencies.
  31
  32 from optparse import OptionParser
  33 import tripe as T
  34 import os as OS
  35 import signal as SIG
  36 import errno as E
  37 import cdb as CDB
  38 import mLib as M
  39 import re as RX
  40 from time import time
  41 import subprocess as PROC
  42
  43 S = T.svcmgr
  44
  45 ###--------------------------------------------------------------------------
  46 ### Running auxiliary commands.
  47
  48 class SelLineQueue (M.SelLineBuffer):
  49   """Glues the select-line-buffer into the coroutine queue system."""
  50
  51   def __new__(cls, file, queue, tag, kind):
  52     """See __init__ for documentation."""
  53     return M.SelLineBuffer.__new__(cls, file.fileno())
  54
  55   def __init__(me, file, queue, tag, kind):
  56     """
  57     Initialize a new line-reading adaptor.
  58
  59     The adaptor reads lines from FILE.  Each line is inserted as a message of
  60     the stated KIND, bearing the TAG, into the QUEUE.  End-of-file is
  61     represented as None.
  62     """
  63     me._q = queue
  64     me._file = file
  65     me._tag = tag
  66     me._kind = kind
  67     me.enable()
  68
  69   @T._callback
  70   def line(me, line):
  71     me._q.put((me._tag, me._kind, line))
  72
  73   @T._callback
  74   def eof(me):
  75     me.disable()
  76     me._q.put((me._tag, me._kind, None))
  77
  78 class ErrorWatch (T.Coroutine):
  79   """
  80   An object which watches stderr streams for errors and converts them into
  81   warnings of the form
  82
  83     WARN watch INFO stderr LINE
  84
  85   The INFO is a list of tokens associated with the file when it was
  86   registered.
  87
  88   Usually there is a single ErrorWatch object, called errorwatch.
  89   """
  90
  91   def __init__(me):
  92     """Initialization: there are no arguments."""
  93     T.Coroutine.__init__(me)
  94     me._q = T.Queue()
  95     me._map = {}
  96     me._seq = 1
  97
  98   def watch(me, file, info):
  99     """
 100     Adds FILE to the collection of files to watch.
 101
 102     INFO will be written in the warning messages from this FILE.  Returns a
 103     sequence number which can be used to unregister the file again.
 104     """
 105     seq = me._seq
 106     me._seq += 1
 107     me._map[seq] = info, SelLineQueue(file, me._q, seq, 'stderr')
 108     return seq
 109
 110   def unwatch(me, seq):
 111     """Stop watching the file with sequence number SEQ."""
 112     del me._map[seq]
 113     return me
 114
 115   def run(me):
 116     """
 117     Coroutine function: read items from the queue and report them.
 118
 119     Unregisters files automatically when they reach EOF.
 120     """
 121     while True:
 122       seq, _, line = me._q.get()
 123       if line is None:
 124         me.unwatch(seq)
 125       else:
 126         S.warn(*['watch'] + me._map[seq][0] + ['stderr', line])
 127
 128 def dbwatch():
 129   """
 130   Coroutine function: wake up every second and notice changes to the
 131   database.  When a change happens, tell the Pinger (q.v.) to rescan its
 132   peers.
 133   """
 134   cr = T.Coroutine.getcurrent()
 135   main = cr.parent
 136   fw = M.FWatch(opts.cdb)
 137   while True:
 138     timer = M.SelTimer(time() + 1, lambda: cr.switch())
 139     main.switch()
 140     if fw.update():
 141       pinger.rescan(False)
 142       S.notify('watch', 'peerdb-update')
 143
 144 class ChildWatch (M.SelSignal):
 145   """
 146   An object which watches for specified processes exiting and reports
 147   terminations by writing items of the form (TAG, 'exit', RESULT) to a queue.
 148
 149   There is usually only one ChildWatch object, called childwatch.
 150   """
 151
 152   def __new__(cls):
 153     """Initialize the child-watcher."""
 154     return M.SelSignal.__new__(cls, SIG.SIGCHLD)
 155
 156   def __init__(me):
 157     """Initialize the child-watcher."""
 158     me._pid = {}
 159     me.enable()
 160
 161   def watch(me, pid, queue, tag):
 162     """
 163     Register PID as a child to watch.  If it exits, write (TAG, 'exit', CODE)
 164     to the QUEUE, where CODE is one of
 165
 166       * None (successful termination)
 167       * ['exit-nonzero', CODE] (CODE is a string!)
 168       * ['exit-signal', 'S' + CODE] (CODE is the signal number as a string)
 169       * ['exit-unknown', STATUS] (STATUS is the entire exit status, in hex)
 170     """
 171     me._pid[pid] = queue, tag
 172     return me
 173
 174   def unwatch(me, pid):
 175     """Unregister PID as a child to watch."""
 176     del me._pid[pid]
 177     return me
 178
 179   @T._callback
 180   def signalled(me):
 181     """
 182     Called when child processes exit: collect exit statuses and report
 183     failures.
 184     """
 185     while True:
 186       try:
 187         pid, status = OS.waitpid(-1, OS.WNOHANG)
 188       except OSError, exc:
 189         if exc.errno == E.ECHILD:
 190           break
 191       if pid == 0:
 192         break
 193       if pid not in me._pid:
 194         continue
 195       queue, tag = me._pid[pid]
 196       if OS.WIFEXITED(status):
 197         exit = OS.WEXITSTATUS(status)
 198         if exit == 0:
 199           code = None
 200         else:
 201           code = ['exit-nonzero', str(exit)]
 202       elif OS.WIFSIGNALED(status):
 203         code = ['exit-signal', 'S' + str(OS.WTERMSIG(status))]
 204       else:
 205         code = ['exit-unknown', hex(status)]
 206       queue.put((tag, 'exit', code))
 207
 208 class Command (object):
 209   """
 210   Represents a running command.
 211
 212   This class is the main interface to the machery provided by the ChildWatch
 213   and ErrorWatch objects.  See also potwatch.
 214   """
 215
 216   def __init__(me, info, queue, tag, args, env):
 217     """
 218     Start a new child process.
 219
 220     The ARGS are a list of arguments to be given to the child process.  The
 221     ENV is either None or a dictionary of environment variable assignments to
 222     override the extant environment.  INFO is a list of tokens to be included
 223     in warnings about the child's stderr output.  If the child writes a line
 224     to standard output, put (TAG, 'stdout', LINE) to the QUEUE.  When the
 225     child exits, write (TAG, 'exit', CODE) to the QUEUE.
 226     """
 227     me._info = info
 228     me._q = queue
 229     me._tag = tag
 230     myenv = OS.environ.copy()
 231     if env: myenv.update(env)
 232     me._proc = PROC.Popen(args = args, env = myenv, bufsize = 1,
 233                           stdout = PROC.PIPE, stderr = PROC.PIPE)
 234     me._lq = SelLineQueue(me._proc.stdout, queue, tag, 'stdout')
 235     errorwatch.watch(me._proc.stderr, info)
 236     childwatch.watch(me._proc.pid, queue, tag)
 237
 238   def __del__(me):
 239     """
 240     If I've been forgotten then stop watching for termination.
 241     """
 242     childwatch.unwatch(me._proc.pid)
 243
 244 def potwatch(what, name, q):
 245   """
 246   Watch the queue Q for activity as reported by a Command object.
 247
 248   Information from the process's stdout is reported as
 249
 250     NOTE WHAT NAME stdout LINE
 251
 252   abnormal termination is reported as
 253
 254     WARN WHAT NAME CODE
 255
 256   where CODE is what the ChildWatch wrote.
 257   """
 258   eofp = deadp = False
 259   while not deadp or not eofp:
 260     _, kind, more = q.get()
 261     if kind == 'stdout':
 262       if more is None:
 263         eofp = True
 264       else:
 265         S.notify('watch', what, name, 'stdout', more)
 266     elif kind == 'exit':
 267       if more: S.warn('watch', what, name, *more)
 268       deadp = True
 269
 270 ###--------------------------------------------------------------------------
 271 ### Peer database utilities.
 272
 273 def timespec(info, key, default):
 274   """Parse INFO[KEY] as a timespec, or return DEFAULT."""
 275   try:
 276     return T.timespec(info[key])
 277   except (KeyError, T.TripeJobError):
 278     return default
 279
 280 def integer(info, key, default):
 281   """Parse INFO[KEY] as an integer, or return DEFAULT."""
 282   try:
 283     return int(info[key])
 284   except (KeyError, ValueError):
 285     return default
 286
 287 def boolean(info, key, default):
 288   """Parse INFO[KEY] as a boolean, or return DEFAULT."""
 289   try:
 290     return info[key] in ['t', 'true', 'y', 'yes', 'on']
 291   except (KeyError, ValueError):
 292     return default
 293
 294 def peerinfo(peer):
 295   """
 296   Return a dictionary containing information about PEER from the database.
 297   """
 298   return dict(M.URLDecode(CDB.init(opts.cdb)['P' + peer], semip = True))
 299
 300 ###--------------------------------------------------------------------------
 301 ### Waking up and watching peers.
 302
 303 def connect(peer, conn = None):
 304   """
 305   Start the job of connecting to the passive PEER.
 306
 307   The CONN string is a shell command which will connect to the peer (via some
 308   back-channel, say ssh and userv), issue a command
 309
 310     SVCSUBMIT connect passive [OPTIONS] USER
 311
 312   and write the resulting challenge to standard error.
 313   """
 314   if conn is None:
 315     try:
 316       conn = peerinfo(peer)['connect']
 317     except KeyError:
 318       return
 319   q = T.Queue()
 320   cmd = Command(['connect', peer], q, 'connect',
 321                 ['/bin/sh', '-c', conn], None)
 322   _, kind, more = q.peek()
 323   if kind == 'stdout':
 324     if more is None:
 325       S.warn('watch', 'connect', peer, 'unexpected-eof')
 326     else:
 327       chal = more
 328       S.greet(peer, chal)
 329       q.get()
 330   potwatch('connect', peer, q)
 331
 332 _pingseq = 0
 333 class PingPeer (object):
 334   """
 335   Object representing a peer which we are pinging to ensure that it is still
 336   present.
 337
 338   PingPeer objects are held by the Pinger (q.v.).  The Pinger maintains an
 339   event queue -- which saves us from having an enormous swarm of coroutines
 340   -- but most of the actual work is done here.
 341
 342   In order to avoid confusion between different PingPeer instances for the
 343   same actual peer, each PingPeer has a sequence number (its `seq'
 344   attribute).  Events for the PingPeer are identified by a (PEER, SEQ) pair.
 345   (Using the PingPeer instance itself will prevent garbage collection of
 346   otherwise defunct instances.)
 347   """
 348
 349   def __init__(me, pinger, queue, peer, info, pingnow):
 350     """
 351     Create a new PingPeer.
 352
 353     The PINGER is the Pinger object we should send the results to.  This is
 354     used when we remove ourselves, if the peer has been explicitly removed.
 355
 356     The QUEUE is the event queue on which timer and ping-command events
 357     should be written.
 358
 359     The PEER is just the peer's name, as a string.
 360
 361     The INFO is the database record for the peer, as a dictionary, or None if
 362     it's not readily available.  (This is just a tweak to save multiple
 363     probes if we don't really need them.)
 364
 365     If PINGNOW is true, then immediately start pinging the peer.  Otherwise
 366     wait until the usual retry interval.
 367     """
 368     global _pingseq
 369     me._pinger = pinger
 370     me._q = queue
 371     me._peer = peer
 372     me.update(info)
 373     me.seq = _pingseq
 374     _pingseq += 1
 375     me._failures = 0
 376     if pingnow:
 377       me._timer = None
 378       me._ping()
 379     else:
 380       me._timer = M.SelTimer(time() + me._every, me._time)
 381
 382   def update(me, info):
 383     """
 384     Refreshes the timer parameters for this peer.  We don't, however,
 385     immediately reschedule anything: that will happen next time anything
 386     interesting happens.
 387     """
 388     if info is None:
 389       info = peerinfo(me._peer)
 390     me._every = timespec(info, 'every', 120)
 391     me._timeout = timespec(info, 'timeout', 10)
 392     me._retries = integer(info, 'retries', 5)
 393     me._connectp = 'connect' in info
 394     return me
 395
 396   def _ping(me):
 397     """
 398     Send a ping to the peer; the result is sent to the Pinger's event queue.
 399     """
 400     S.rawcommand(T.TripeAsynchronousCommand(
 401       me._q, (me._peer, me.seq),
 402       ['PING',
 403        '-background', S.bgtag(),
 404        '-timeout', str(me._timeout),
 405        '--',
 406        me._peer]))
 407
 408   def event(me, code, stuff):
 409     """
 410     Respond to an event which happened to this peer.
 411
 412     Timer events indicate that we should start a new ping.  (The server has
 413     its own timeout which detects lost packets.)
 414
 415     We trap unknown-peer responses and detach from the Pinger.
 416
 417     If the ping fails and we run out of retries, we attempt to restart the
 418     connection.
 419     """
 420     if code == 'TIMER':
 421       me._failures = 0
 422       me._ping()
 423     elif code == 'FAIL':
 424       S.notify('watch', 'ping-failed', me._peer, *stuff)
 425       if stuff and stuff[0] == 'unknown-peer':
 426         me._pinger.kill(me._peer)
 427     elif code == 'INFO':
 428       if stuff[0] == 'ping-ok':
 429         if me._failures > 0:
 430           S.warn('watch', 'ping-ok', me._peer)
 431         me._timer = M.SelTimer(time() + me._every, me._time)
 432       elif stuff[0] == 'ping-timeout':
 433         me._failures += 1
 434         S.warn('watch', 'ping-timeout', me._peer,
 435                'attempt', str(me._failures), 'of', str(me._retries))
 436         if me._failures < me._retries:
 437           me._ping()
 438         else:
 439           info = peerinfo(me._peer)
 440           if 'connect' in info:
 441             S.warn('watch', 'reconnecting', me._peer)
 442             S.forcekx(me._peer)
 443             T.spawn(T.Coroutine(connect), me._peer)
 444             me._timer = M.SelTimer(time() + me._every, me._time)
 445           else:
 446             S.kill(me._peer)
 447       elif stuff[0] == 'ping-peer-died':
 448         me._pinger.kill(me._peer)
 449
 450   @T._callback
 451   def _time(me):
 452     """
 453     Handle timer callbacks by posting a timeout event on the queue.
 454     """
 455     me._timer = None
 456     me._q.put(((me._peer, me.seq), 'TIMER', None))
 457
 458   def __str__(me):
 459     return 'PingPeer(%s, %d, f = %d)' % (me._peer, me.seq, me._failures)
 460   def __repr__(me):
 461     return str(me)
 462
 463 class Pinger (T.Coroutine):
 464   """
 465   The Pinger keeps track of the peers which we expect to be connected and
 466   takes action if they seem to stop responding.
 467
 468   There is usually only one Pinger, called pinger.
 469
 470   The Pinger maintains a collection of PingPeer objects, and an event queue.
 471   The PingPeers direct the results of their pings, and timer events, to the
 472   event queue.  The Pinger's coroutine picks items off the queue and
 473   dispatches them back to the PingPeers as appropriate.
 474   """
 475
 476   def __init__(me):
 477     """Initialize the Pinger."""
 478     T.Coroutine.__init__(me)
 479     me._peers = {}
 480     me._q = T.Queue()
 481
 482   def run(me):
 483     """
 484     Coroutine function: reads the pinger queue and sends events to the
 485     PingPeer objects they correspond to.
 486     """
 487     while True:
 488       (peer, seq), code, stuff = me._q.get()
 489       if peer in me._peers and seq == me._peers[peer].seq:
 490         me._peers[peer].event(code, stuff)
 491
 492   def add(me, peer, info, pingnow):
 493     """
 494     Add PEER to the collection of peers under the Pinger's watchful eye.
 495     The arguments are as for PingPeer: see above.
 496     """
 497     me._peers[peer] = PingPeer(me, me._q, peer, info, pingnow)
 498     return me
 499
 500   def kill(me, peer):
 501     """Remove PEER from the peers being watched by the Pinger."""
 502     del me._peers[peer]
 503     return me
 504
 505   def rescan(me, startup):
 506     """
 507     General resynchronization method.
 508
 509     We scan the list of peers (with connect scripts) known at the server.
 510     Any which are known to the Pinger but aren't known to the server are
 511     removed from our list; newly arrived peers are added.  (Note that a peer
 512     can change state here either due to the server sneakily changing its list
 513     without issuing notifications or, more likely, the database changing its
 514     idea of whether a peer is interesting.)  Finally, PingPeers which are
 515     still present are prodded to update their timing parameters.
 516
 517     This method is called once at startup to pick up the peers already
 518     installed, and again by the dbwatcher coroutine when it detects a change
 519     to the database.
 520     """
 521     correct = {}
 522     for peer in S.list():
 523       try:
 524         info = peerinfo(peer)
 525       except KeyError:
 526         continue
 527       if boolean(info, 'watch', False):
 528         correct[peer] = info
 529     for peer, obj in me._peers.items():
 530       if peer in correct:
 531         obj.update(correct[peer])
 532       else:
 533         del me._peers[peer]
 534     for peer, info in correct.iteritems():
 535       if peer not in me._peers:
 536         if startup:
 537           ifname = S.ifname(peer)
 538           addr = S.addr(peer)
 539           addpeer(info, peer, ifname, *addr)
 540         else:
 541           me.add(peer, info, True)
 542     return me
 543
 544   def adopted(me):
 545     """
 546     Returns the list of peers being watched by the Pinger.
 547     """
 548     return me._peers.keys()
 549
 550 ###--------------------------------------------------------------------------
 551 ### New connections.
 552
 553 def encode_envvars(env, prefix, vars):
 554   """
 555   Encode the variables in VARS suitably for including in a program
 556   environment.  Lowercase letters in variable names are forced to uppercase;
 557   runs of non-alphanumeric characters are replaced by single underscores; and
 558   the PREFIX is prepended.  The resulting variables are written to ENV.
 559   """
 560   for k, v in vars.iteritems():
 561     env[prefix + r_bad.sub('_', k.upper())] = v
 562
 563 r_bad = RX.compile(r'[\W_]+')
 564 def envvars(info):
 565   """
 566   Translate the database INFO dictionary for a peer into a dictionary of
 567   environment variables with plausible upper-case names and a P_ prefix.
 568   Also collect the crypto information into A_ variables.
 569   """
 570   env = {}
 571   encode_envvars(env, 'P_', info)
 572   encode_envvars(env, 'A_', S.algs())
 573   return env
 574
 575 def ifupdown(what, peer, info, *args):
 576   """
 577   Run the interface up/down script for a peer.
 578
 579   WHAT is 'ifup' or 'ifdown'.  PEER names the peer in question.  INFO is the
 580   database record dictionary.  ARGS is a list of arguments to pass to the
 581   script, in addition to the peer name.
 582
 583   The command is run and watched in the background by potwatch.
 584   """
 585   q = T.Queue()
 586   c = Command([what, peer], q, what,
 587               M.split(info[what], quotep = True)[0] +
 588               [peer] + list(args),
 589               envvars(info))
 590   potwatch(what, peer, q)
 591
 592 def addpeer(info, peer, ifname, *addr):
 593   """
 594   Add a new peer to our collection.
 595
 596   INFO is the peer information dictionary, or None if we don't have one yet.
 597
 598   PEER names the peer; IFNAME is the interface name for its tunnel; and ADDR
 599   is the list of tokens representing its address.
 600
 601   We try to bring up the interface and provoke a connection to the peer if
 602   it's passive.
 603   """
 604   if info is None:
 605     try:
 606       info = peerinfo(peer)
 607     except KeyError:
 608       return
 609   if 'ifup' in info:
 610     T.Coroutine(ifupdown).switch('ifup', peer, info, ifname, *addr)
 611   if 'connect' in info:
 612     T.Coroutine(connect).switch(peer, info['connect'])
 613   if boolean(info, 'watch', False):
 614     pinger.add(peer, info, False)
 615
 616 def delpeer(peer):
 617   """Drop the PEER from the Pinger and put its interface to bed."""
 618   try:
 619     info = peerinfo(peer)
 620   except KeyError:
 621     return
 622   try:
 623     pinger.kill(peer)
 624   except KeyError:
 625     pass
 626   if 'ifdown' in info:
 627     T.Coroutine(ifupdown).switch('ifdown', peer, info)
 628
 629 def notify(_, code, *rest):
 630   """
 631   Watch for notifications.
 632
 633   We trap ADD and KILL notifications, and send them straight to addpeer and
 634   delpeer respectively.
 635   """
 636   if code == 'ADD':
 637     addpeer(None, *rest)
 638   elif code == 'KILL':
 639     delpeer(*rest)
 640
 641 ###--------------------------------------------------------------------------
 642 ### Command stubs.
 643
 644 def cmd_stub(*args):
 645   raise T.TripeJobError('not-implemented')
 646
 647 def cmd_kick(peer):
 648   """
 649   kick PEER: Force a new connection attempt for PEER
 650   """
 651   if peer not in pinger.adopted():
 652     raise T.TripeJobError('peer-not-adopted', peer)
 653   T.spawn(T.Coroutine(connect), peer)
 654
 655 def cmd_adopted():
 656   """
 657   adopted: Report a list of adopted peers.
 658   """
 659   for peer in pinger.adopted():
 660     T.svcinfo(peer)
 661
 662 ###--------------------------------------------------------------------------
 663 ### Start up.
 664
 665 def setup():
 666   """
 667   Service setup.
 668
 669   Register the notification watcher, and rescan the peers.
 670   """
 671   S.handler['NOTE'] = notify
 672   S.watch('+n')
 673   pinger.rescan(opts.startup)
 674
 675 def init():
 676   """
 677   Initialization to be done before service startup.
 678   """
 679   global errorwatch, childwatch, pinger
 680   errorwatch = ErrorWatch()
 681   childwatch = ChildWatch()
 682   pinger = Pinger()
 683   T.Coroutine(dbwatch).switch()
 684   errorwatch.switch()
 685   pinger.switch()
 686
 687 def parse_options():
 688   """
 689   Parse the command-line options.
 690
 691   Automatically changes directory to the requested configdir, and turns on
 692   debugging.  Returns the options object.
 693   """
 694   op = OptionParser(usage = '%prog [-a FILE] [-d DIR]',
 695                     version = '%%prog %s' % VERSION)
 696
 697   op.add_option('-a', '--admin-socket',
 698                 metavar = 'FILE', dest = 'tripesock', default = T.tripesock,
 699                 help = 'Select socket to connect to [default %default]')
 700   op.add_option('-d', '--directory',
 701                 metavar = 'DIR', dest = 'dir', default = T.configdir,
 702                 help = 'Select current diretory [default %default]')
 703   op.add_option('-p', '--peerdb',
 704                 metavar = 'FILE', dest = 'cdb', default = T.peerdb,
 705                 help = 'Select peers database [default %default]')
 706   op.add_option('--daemon', dest = 'daemon',
 707                 default = False, action = 'store_true',
 708                 help = 'Become a daemon after successful initialization')
 709   op.add_option('--debug', dest = 'debug',
 710                 default = False, action = 'store_true',
 711                 help = 'Emit debugging trace information')
 712   op.add_option('--startup', dest = 'startup',
 713                 default = False, action = 'store_true',
 714                 help = 'Being called as part of the server startup')
 715
 716   opts, args = op.parse_args()
 717   if args: op.error('no arguments permitted')
 718   OS.chdir(opts.dir)
 719   T._debug = opts.debug
 720   return opts
 721
 722 ## Service table, for running manually.
 723 service_info = [('watch', T.VERSION, {
 724   'adopted': (0, 0, '', cmd_adopted),
 725   'kick': (1, 1, 'PEER', cmd_kick)
 726 })]
 727
 728 if __name__ == '__main__':
 729   opts = parse_options()
 730   T.runservices(opts.tripesock, service_info,
 731                 init = init, setup = setup,
 732                 daemon = opts.daemon)
 733
 734 ###----- That's all, folks --------------------------------------------------