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       ['EPING',
 403        '-background', S.bgtag(),
 404        '-timeout', str(me._timeout),
 405        '--',
 406        me._peer]))
 407
 408   def _reconnect(me):
 409     info = peerinfo(me._peer)
 410     if 'connect' in info:
 411       S.warn('watch', 'reconnecting', me._peer)
 412       S.forcekx(me._peer)
 413       T.spawn(connect, me._peer)
 414       me._timer = M.SelTimer(time() + me._every, me._time)
 415     else:
 416       S.kill(me._peer)
 417
 418   def event(me, code, stuff):
 419     """
 420     Respond to an event which happened to this peer.
 421
 422     Timer events indicate that we should start a new ping.  (The server has
 423     its own timeout which detects lost packets.)
 424
 425     We trap unknown-peer responses and detach from the Pinger.
 426
 427     If the ping fails and we run out of retries, we attempt to restart the
 428     connection.
 429     """
 430     if code == 'TIMER':
 431       me._failures = 0
 432       me._ping()
 433     elif code == 'FAIL':
 434       S.notify('watch', 'ping-failed', me._peer, *stuff)
 435       if not stuff:
 436         pass
 437       elif stuff[0] == 'unknown-peer':
 438         me._pinger.kill(me._peer)
 439       elif stuff[0] == 'ping-send-failed':
 440         me._reconnect()
 441     elif code == 'INFO':
 442       if stuff[0] == 'ping-ok':
 443         if me._failures > 0:
 444           S.warn('watch', 'ping-ok', me._peer)
 445         me._timer = M.SelTimer(time() + me._every, me._time)
 446       elif stuff[0] == 'ping-timeout':
 447         me._failures += 1
 448         S.warn('watch', 'ping-timeout', me._peer,
 449                'attempt', str(me._failures), 'of', str(me._retries))
 450         if me._failures < me._retries:
 451           me._ping()
 452         else:
 453           me._reconnect()
 454       elif stuff[0] == 'ping-peer-died':
 455         me._pinger.kill(me._peer)
 456
 457   @T._callback
 458   def _time(me):
 459     """
 460     Handle timer callbacks by posting a timeout event on the queue.
 461     """
 462     me._timer = None
 463     me._q.put(((me._peer, me.seq), 'TIMER', None))
 464
 465   def __str__(me):
 466     return 'PingPeer(%s, %d, f = %d)' % (me._peer, me.seq, me._failures)
 467   def __repr__(me):
 468     return str(me)
 469
 470 class Pinger (T.Coroutine):
 471   """
 472   The Pinger keeps track of the peers which we expect to be connected and
 473   takes action if they seem to stop responding.
 474
 475   There is usually only one Pinger, called pinger.
 476
 477   The Pinger maintains a collection of PingPeer objects, and an event queue.
 478   The PingPeers direct the results of their pings, and timer events, to the
 479   event queue.  The Pinger's coroutine picks items off the queue and
 480   dispatches them back to the PingPeers as appropriate.
 481   """
 482
 483   def __init__(me):
 484     """Initialize the Pinger."""
 485     T.Coroutine.__init__(me)
 486     me._peers = {}
 487     me._q = T.Queue()
 488
 489   def run(me):
 490     """
 491     Coroutine function: reads the pinger queue and sends events to the
 492     PingPeer objects they correspond to.
 493     """
 494     while True:
 495       (peer, seq), code, stuff = me._q.get()
 496       if peer in me._peers and seq == me._peers[peer].seq:
 497         me._peers[peer].event(code, stuff)
 498
 499   def add(me, peer, info, pingnow):
 500     """
 501     Add PEER to the collection of peers under the Pinger's watchful eye.
 502     The arguments are as for PingPeer: see above.
 503     """
 504     me._peers[peer] = PingPeer(me, me._q, peer, info, pingnow)
 505     return me
 506
 507   def kill(me, peer):
 508     """Remove PEER from the peers being watched by the Pinger."""
 509     del me._peers[peer]
 510     return me
 511
 512   def rescan(me, startup):
 513     """
 514     General resynchronization method.
 515
 516     We scan the list of peers (with connect scripts) known at the server.
 517     Any which are known to the Pinger but aren't known to the server are
 518     removed from our list; newly arrived peers are added.  (Note that a peer
 519     can change state here either due to the server sneakily changing its list
 520     without issuing notifications or, more likely, the database changing its
 521     idea of whether a peer is interesting.)  Finally, PingPeers which are
 522     still present are prodded to update their timing parameters.
 523
 524     This method is called once at startup to pick up the peers already
 525     installed, and again by the dbwatcher coroutine when it detects a change
 526     to the database.
 527     """
 528     correct = {}
 529     for peer in S.list():
 530       try:
 531         info = peerinfo(peer)
 532       except KeyError:
 533         continue
 534       if boolean(info, 'watch', False):
 535         correct[peer] = info
 536     for peer, obj in me._peers.items():
 537       if peer in correct:
 538         obj.update(correct[peer])
 539       else:
 540         del me._peers[peer]
 541     for peer, info in correct.iteritems():
 542       if peer not in me._peers:
 543         if startup:
 544           ifname = S.ifname(peer)
 545           addr = S.addr(peer)
 546           T.defer(addpeer, info, peer, ifname, *addr)
 547         else:
 548           me.add(peer, info, True)
 549     return me
 550
 551   def adopted(me):
 552     """
 553     Returns the list of peers being watched by the Pinger.
 554     """
 555     return me._peers.keys()
 556
 557 ###--------------------------------------------------------------------------
 558 ### New connections.
 559
 560 def encode_envvars(env, prefix, vars):
 561   """
 562   Encode the variables in VARS suitably for including in a program
 563   environment.  Lowercase letters in variable names are forced to uppercase;
 564   runs of non-alphanumeric characters are replaced by single underscores; and
 565   the PREFIX is prepended.  The resulting variables are written to ENV.
 566   """
 567   for k, v in vars.iteritems():
 568     env[prefix + r_bad.sub('_', k.upper())] = v
 569
 570 r_bad = RX.compile(r'[\W_]+')
 571 def envvars(info):
 572   """
 573   Translate the database INFO dictionary for a peer into a dictionary of
 574   environment variables with plausible upper-case names and a P_ prefix.
 575   Also collect the crypto information into A_ variables.
 576   """
 577   env = {}
 578   encode_envvars(env, 'P_', info)
 579   encode_envvars(env, 'A_', S.algs())
 580   return env
 581
 582 def ifupdown(what, peer, info, *args):
 583   """
 584   Run the interface up/down script for a peer.
 585
 586   WHAT is 'ifup' or 'ifdown'.  PEER names the peer in question.  INFO is the
 587   database record dictionary.  ARGS is a list of arguments to pass to the
 588   script, in addition to the peer name.
 589
 590   The command is run and watched in the background by potwatch.
 591   """
 592   q = T.Queue()
 593   c = Command([what, peer], q, what,
 594               M.split(info[what], quotep = True)[0] +
 595               [peer] + list(args),
 596               envvars(info))
 597   potwatch(what, peer, q)
 598
 599 def addpeer(info, peer, ifname, *addr):
 600   """
 601   Add a new peer to our collection.
 602
 603   INFO is the peer information dictionary, or None if we don't have one yet.
 604
 605   PEER names the peer; IFNAME is the interface name for its tunnel; and ADDR
 606   is the list of tokens representing its address.
 607
 608   We try to bring up the interface and provoke a connection to the peer if
 609   it's passive.
 610   """
 611   if info is None:
 612     try:
 613       info = peerinfo(peer)
 614     except KeyError:
 615       return
 616   if 'ifup' in info:
 617     T.Coroutine(ifupdown, name = 'ifup %s' % peer) \
 618                           .switch('ifup', peer, info, ifname, *addr)
 619   if 'connect' in info:
 620     T.Coroutine(connect, name = 'connect %s' % peer) \
 621                          .switch(peer, info['connect'])
 622   if boolean(info, 'watch', False):
 623     pinger.add(peer, info, False)
 624
 625 def delpeer(peer):
 626   """Drop the PEER from the Pinger and put its interface to bed."""
 627   try:
 628     info = peerinfo(peer)
 629   except KeyError:
 630     return
 631   try:
 632     pinger.kill(peer)
 633   except KeyError:
 634     pass
 635   if 'ifdown' in info:
 636     T.Coroutine(ifupdown, name = 'ifdown %s' % peer) \
 637                           .switch('ifdown', peer, info)
 638
 639 def notify(_, code, *rest):
 640   """
 641   Watch for notifications.
 642
 643   We trap ADD and KILL notifications, and send them straight to addpeer and
 644   delpeer respectively.
 645   """
 646   if code == 'ADD':
 647     addpeer(None, *rest)
 648   elif code == 'KILL':
 649     delpeer(*rest)
 650
 651 ###--------------------------------------------------------------------------
 652 ### Command stubs.
 653
 654 def cmd_stub(*args):
 655   raise T.TripeJobError('not-implemented')
 656
 657 def cmd_kick(peer):
 658   """
 659   kick PEER: Force a new connection attempt for PEER
 660   """
 661   if peer not in pinger.adopted():
 662     raise T.TripeJobError('peer-not-adopted', peer)
 663   T.spawn(connect, peer)
 664
 665 def cmd_adopted():
 666   """
 667   adopted: Report a list of adopted peers.
 668   """
 669   for peer in pinger.adopted():
 670     T.svcinfo(peer)
 671
 672 ###--------------------------------------------------------------------------
 673 ### Start up.
 674
 675 def setup():
 676   """
 677   Service setup.
 678
 679   Register the notification watcher, and rescan the peers.
 680   """
 681   S.handler['NOTE'] = notify
 682   S.watch('+n')
 683   pinger.rescan(opts.startup)
 684
 685 def init():
 686   """
 687   Initialization to be done before service startup.
 688   """
 689   global errorwatch, childwatch, pinger
 690   errorwatch = ErrorWatch()
 691   childwatch = ChildWatch()
 692   pinger = Pinger()
 693   T.Coroutine(dbwatch, name = 'dbwatch').switch()
 694   errorwatch.switch()
 695   pinger.switch()
 696
 697 def parse_options():
 698   """
 699   Parse the command-line options.
 700
 701   Automatically changes directory to the requested configdir, and turns on
 702   debugging.  Returns the options object.
 703   """
 704   op = OptionParser(usage = '%prog [-a FILE] [-d DIR]',
 705                     version = '%%prog %s' % VERSION)
 706
 707   op.add_option('-a', '--admin-socket',
 708                 metavar = 'FILE', dest = 'tripesock', default = T.tripesock,
 709                 help = 'Select socket to connect to [default %default]')
 710   op.add_option('-d', '--directory',
 711                 metavar = 'DIR', dest = 'dir', default = T.configdir,
 712                 help = 'Select current diretory [default %default]')
 713   op.add_option('-p', '--peerdb',
 714                 metavar = 'FILE', dest = 'cdb', default = T.peerdb,
 715                 help = 'Select peers database [default %default]')
 716   op.add_option('--daemon', dest = 'daemon',
 717                 default = False, action = 'store_true',
 718                 help = 'Become a daemon after successful initialization')
 719   op.add_option('--debug', dest = 'debug',
 720                 default = False, action = 'store_true',
 721                 help = 'Emit debugging trace information')
 722   op.add_option('--startup', dest = 'startup',
 723                 default = False, action = 'store_true',
 724                 help = 'Being called as part of the server startup')
 725
 726   opts, args = op.parse_args()
 727   if args: op.error('no arguments permitted')
 728   OS.chdir(opts.dir)
 729   T._debug = opts.debug
 730   return opts
 731
 732 ## Service table, for running manually.
 733 service_info = [('watch', T.VERSION, {
 734   'adopted': (0, 0, '', cmd_adopted),
 735   'kick': (1, 1, 'PEER', cmd_kick)
 736 })]
 737
 738 if __name__ == '__main__':
 739   opts = parse_options()
 740   T.runservices(opts.tripesock, service_info,
 741                 init = init, setup = setup,
 742                 daemon = opts.daemon)
 743
 744 ###----- That's all, folks --------------------------------------------------