chiark / gitweb /
Allow the caller to configure the administration socket permissions.
[tripe] / py / rmcr.py
1 ### -*-python-*-
2 ###
3 ### Rich man's coroutines
4 ###
5 ### (c) 2006 Straylight/Edgeware
6 ###
7
8 ###----- Licensing notice ---------------------------------------------------
9 ###
10 ### This file is part of Trivial IP Encryption (TrIPE).
11 ###
12 ### TrIPE is free software; you can redistribute it and/or modify
13 ### it under the terms of the GNU General Public License as published by
14 ### the Free Software Foundation; either version 2 of the License, or
15 ### (at your option) any later version.
16 ###
17 ### TrIPE is distributed in the hope that it will be useful,
18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 ### GNU General Public License for more details.
21 ###
22 ### You should have received a copy of the GNU General Public License
23 ### along with TrIPE; if not, write to the Free Software Foundation,
24 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25
26 __pychecker__ = 'self=me'
27
28 ###--------------------------------------------------------------------------
29 ### External dependencies.
30
31 import thread as T
32 from sys import exc_info, excepthook
33
34 ###--------------------------------------------------------------------------
35 ### What's going on?
36 ###
37 ### A coroutine is just a thread.  Each coroutine has a recursive lock
38 ### associated with it.  The lock is almost always held.  In order to switch
39 ### to a coroutine, one releases its lock and then (re)locks one's own.
40
41 ###--------------------------------------------------------------------------
42 ### Low-level machinery.
43
44 __debug = False
45 def _debug(msg):
46   if __debug:
47     print '+++ %s: %s' % (T.get_ident(), msg)
48
49 def _switchto(cr, arg = None, exc = None):
50   """Switch to coroutine CR."""
51   global active
52   _debug('> _switchto(%s, %s, %s)' % (cr, arg, exc))
53   if not cr.livep:
54     raise ValueError, 'coroutine is dead'
55   cr._arg = arg
56   cr._exc = exc
57   if cr is active:
58     _debug('  _switchto: self-switch to %s' % cr)
59   else:
60     _debug('  _switchto: switch from %s to %s' % (active, cr))
61     active = cr
62     _debug('  _switchto: %s releasing' % cr)
63     assert cr._lk.locked()
64     cr._lk.release()
65   _debug('< _switchto')
66
67 ###--------------------------------------------------------------------------
68 ### Coroutine object.
69
70 def findvictim(cr):
71   """Find an appropriate victim coroutine for something, starting from CR."""
72   while not cr:
73     if cr is None:
74       return main
75     cr = cr.parent
76   return cr
77
78 class Coroutine (object):
79   """Heard of lightweight threads?  Well, this is a heavyweight coroutine."""
80
81   def __init__(me, func = None, name = None, parent = None, __tid = None):
82     """
83     Create a new coroutine object.
84
85     The new coroutine is immediately activated.  FUNC is the function to run,
86     and defaults to the coroutine object's `run' method, so subclassing is a
87     reasonable thing to do; NAME is a friendly name for the coroutine, and
88     shows up in debug traces.  The __TID argument is used internally for
89     special effects, and shouldn't be used by external callers.
90     """
91     global active
92     _debug('> __init__(%s, func = %s, tid = %s)' % (name, func, __tid))
93     me.name = name
94     me._lk = T.allocate_lock()
95     _debug('  __init__: %s locking' % me)
96     me._lk.acquire()
97     me.livep = True
98     me._exc = None
99     me._arg = None
100     me.parent = parent or active
101     me._onexit = [None, None]
102     if __tid is not None:
103       me._tid = __tid
104       _debug('  __init__: manufacture cr %s with existing thread %d' %
105              (me, __tid))
106       me._startp = False
107     else:
108       me._func = func or me.run
109       me._tid = T.start_new_thread(me._start, ())
110       me._startp = True
111       assert me._lk.locked()
112       _debug('  __init__: create %s with new thread %d' % (me, me._tid))
113     _debug('< __init__(%s)' % me)
114
115   def __str__(me):
116     """Stringify a coroutine using its name if possible."""
117     if me.name is not None:
118       return '<Coroutine %s>' % me.name
119     else:
120       return repr(me)
121
122   def _start(me):
123     """
124     Start up the coroutine.
125
126     Wait for this coroutine to become active, and then run the user's
127     function.  When (if) that returns, mark the coroutine as dead.
128     """
129     _debug('> _start(%s)' % (me))
130     args, kwargs = me._wait()
131     _debug('  start(%s): args = %s, kwargs = %s' % (me, args, kwargs))
132     me._startp = False
133     try:
134       try:
135         _debug('  _start(%s): call user (args = %s, kwargs = %s)' %
136                (me, args, kwargs))
137         me._onexit = [me._func(*args, **kwargs), None]
138       except:
139         exc = exc_info()
140         _debug('  _start(%s): caught exception (%s)' % (me, exc))
141         me._onexit = [None, exc]
142     finally:
143       _debug('  _start(%s): finally' % me)
144       _debug('  _start(%s): _onexit = %s' % (me, me._onexit))
145       me.livep = False
146       _switchto(findvictim(me.parent), *me._onexit)
147     _debug('< _start(%s)' % me)
148
149   def _wait(me):
150     """Wait for this coroutine to become active."""
151     global active
152     _debug('> _wait(%s)' % me)
153     me._lk.acquire()
154     while me is not active:
155       _debug('  _wait(%s): locking' % me)
156       me._lk.acquire()
157     _debug('  _wait(%s): active, arg = %s, exc = %s' %
158            (me, me._arg, me._exc))
159     if me._exc:
160       raise me._exc[0], me._exc[1], me._exc[2]
161     _debug('< _wait(%s): %s' % (me, me._arg))
162     return me._arg
163
164   def switch(me, *args, **kwargs):
165     """Switch to this coroutine, passing it the object OBJ."""
166     global active
167     _debug('> switch(%s, args = %s, kwargs = %s)' % (me, args, kwargs))
168     if me._startp:
169       obj = args, kwargs
170     else:
171       obj, = args or (None,)
172       assert not kwargs
173     old = active
174     _switchto(me, obj)
175     _debug('< switch')
176     return old._wait()
177
178   def getcurrent():
179     return active
180   getcurrent = staticmethod(getcurrent)
181
182   def __nonzero__(me):
183     return me.livep
184
185   def throw(me, exc, arg = None, tb = None):
186     """
187     Switch to this coroutine, throwing it an exception.
188
189     The exception is given by EXC, ARG and TB, which form the exception,
190     argument, traceback triple.
191     """
192     global active
193     _debug('> throw(%s, %s, args = %s)' % (me, exc, arg))
194     old = active
195     me._exc = [exc, arg, tb]
196     _switchto(me, None)
197     _debug('< throw')
198     return old._wait()
199
200   def run(me, *args, **kw):
201     raise Exception('Coroutine has no body to run')
202
203 ###--------------------------------------------------------------------------
204 ### Setup stuff.
205
206 active = None
207 main = Coroutine(_Coroutine__tid = T.get_ident(), name = '_main')
208 active = main
209
210 ###----- That's all, folks --------------------------------------------------