Fix simplefunc return bug.
[pdm.git] / pdm / perf.py
1 """Python Daemon Management -- PERF utilities
2
3 This module serves two purposes: It has a few utility classes
4 for implementing PERF interfaces in common ways, and uses those
5 classes to implement some standard PERF objects that can be used by
6 PERF clients connecting to any PERF server.
7
8 See the documentation for L{pdm.srv.perf} for a description of the
9 various PERF interfaces.
10
11 It contains two named PERF objects:
12
13  - sysres -- A directory containing the following objects pertaining
14    to the resource usage of the server process:
15
16     - realtime -- An attribute returning the amount of real time since
17       the PDM module was imported (which likely coincides with the
18       amount of time the server process has been running).
19
20     - cputime -- An attribute returning the amount of CPU time
21       consumed by the server process (in both user and kernel mode).
22
23     - utime -- An attribute returning the amount of CPU time the
24       server process has spent in user mode.
25
26     - stime -- An attribute returning the amount of CPU time the
27       server process has spent in kernel mode.
28
29     - maxrss -- An attribute returning the largest resident set size
30       the server process has used during its lifetime.
31
32     - rusage -- An attribute returning the current rusage of the
33       server process.
34
35  - sysinfo -- A directory containing the following objects pertaining
36    to the environment of the server process:
37
38     - pid -- An attribute returning the PID of the server process.
39
40     - uname -- An attribute returning the uname information of the
41       system.
42
43     - hostname -- An attribute returning the hostname of the system.
44
45     - platform -- An attribute returning the Python build platform.
46 """
47
48 import os, sys, time, socket, threading
49
50 __all__ = ["attrinfo", "simpleattr", "valueattr", "eventobj",
51            "staticdir", "event", "procevent", "startevent",
52            "finishevent"]
53
54 class error(Exception):
55     pass
56 class nosuchname(LookupError, error):
57     pass
58 class nosuchproto(error):
59     pass
60
61 class attrinfo(object):
62     """The return value of the `attrinfo' method on `attr' objects as
63     described in L{pdm.srv.perf}.
64
65     Currently contains a single data field, `desc', which should have
66     a human-readable description of the purpose of the attribute.
67     """
68     def __init__(self, desc = None):
69         self.desc = desc
70
71 class perfobj(object):
72     def __init__(self, *args, **kwargs):
73         super().__init__()
74     
75     def pdm_protocols(self):
76         return []
77
78 class simpleattr(perfobj):
79     """An implementation of the `attr' interface, which is initialized
80     with a function, and returns whatever that function returns when
81     read.
82     """
83     def __init__(self, func, info = None, *args, **kwargs):
84         super().__init__(*args, **kwargs)
85         self.func = func
86         if info is None:
87             info = attrinfo()
88         self.info = info
89
90     def readattr(self):
91         return self.func()
92
93     def attrinfo(self):
94         return self.info
95
96     def pdm_protocols(self):
97         return super().pdm_protocols() + ["attr"]
98
99 class valueattr(perfobj):
100     """An implementation of the `attr' interface, which is initialized
101     with a single value, and returns that value when read. Subsequent
102     updates to the value are reflected in subsequent reads.
103     """
104     def __init__(self, init, info = None, *args, **kwargs):
105         super().__init__(*args, **kwargs)
106         self.value = init
107         if info is None:
108             info = attrinfo()
109         self.info = info
110
111     def readattr(self):
112         return self.value
113
114     def attrinfo(self):
115         return self.info
116
117     def pdm_protocols(self):
118         return super().pdm_protocols() + ["attr"]
119
120 class eventobj(perfobj):
121     """An implementation of the `event' interface. It keeps track of
122     subscribers, and will multiplex any event to all current
123     subscribers when submitted with the `notify' method.
124     """
125     def __init__(self, *args, **kwargs):
126         super().__init__(*args, **kwargs)
127         self.subscribers = set()
128
129     def subscribe(self, cb):
130         if cb in self.subscribers:
131             raise ValueError("Already subscribed")
132         self.subscribers.add(cb)
133
134     def unsubscribe(self, cb):
135         self.subscribers.remove(cb)
136
137     def notify(self, event):
138         """Notify all subscribers with the given event object."""
139         for cb in list(self.subscribers):
140             try:
141                 cb(event)
142             except: pass
143
144     def pdm_protocols(self):
145         return super().pdm_protocols() + ["event"]
146
147 class staticdir(perfobj):
148     """An implementation of the `dir' interface. Put other PERF
149     objects in it using the normal dict assignment syntax, and it will
150     return them to requesting clients.
151     """
152     def __init__(self, *args, **kwargs):
153         super().__init__(*args, **kwargs)
154         self.map = {}
155
156     def __setitem__(self, name, ob):
157         self.map[name] = ob
158
159     def __delitem__(self, name):
160         del self.map[name]
161         
162     def __getitem__(self, name):
163         return self.map[name]
164
165     def get(self, name, default = None):
166         return self.map.get(name, default)
167
168     def listdir(self):
169         return list(self.map.keys())
170
171     def lookup(self, name):
172         return self.map[name]
173
174     def pdm_protocols(self):
175         return super().pdm_protocols() + ["dir"]
176
177 class simplefunc(perfobj):
178     """An implementation of the `invoke' interface. Put callables in
179     it using the normal dict assignment syntax, and it will call them
180     when invoked with the corresponding method name. Additionally, it
181     updates itself with any keyword-arguments it is initialized with."""
182     def __init__(self, *args, **kwargs):
183         super().__init__(*args)
184         self.map = {}
185         self.map.update(kwargs)
186
187     def __setitem__(self, name, func):
188         self.map[name] = func
189
190     def __delitem__(self, name):
191         del self.map[name]
192
193     def invoke(self, method, *args, **kwargs):
194         if method not in self.map:
195             raise AttributeError(method)
196         self.map[method](*args, **kwargs)
197
198     def pdm_protocols(self):
199         return super().pdm_protocols() + ["invoke"]
200
201 class event(object):
202     """This class should be subclassed by all event objects sent via
203     the `event' interface. Its main utility is that it keeps track of
204     the time it was created, so that listening clients can precisely
205     measure the time between event notifications.
206
207     Subclasses should make sure to call the __init__ method if they
208     override it.
209     """
210     def __init__(self):
211         self.time = time.time()
212
213 idlock = threading.Lock()
214 procevid = 0
215
216 def getprocid():
217     global procevid
218     idlock.acquire()
219     try:
220         ret = procevid
221         procevid += 1
222         return ret
223     finally:
224         idlock.release()
225
226 class procevent(event):
227     """A subclass of the `event' class meant to group several events
228     related to the same process. Create a new process by creating (a
229     subclass of) the `startevent' class, and subsequent events in the
230     same process by passing that startevent as the `id' parameter.
231
232     It works by having `startevent' allocate a unique ID for each
233     process, and every other procevent initializing from that
234     startevent copying the ID. The data field `id' contains the ID so
235     that it can be compared by clients.
236
237     An example of such a process might be a client connection, where a
238     `startevent' is emitted when a client connects, another subclass
239     of `procevent' emitted when the client runs a command, and a
240     `finishevent' emitted when the connection is closed.
241     """
242     def __init__(self, id):
243         super().__init__()
244         if isinstance(id, procevent):
245             self.id = id.id
246         else:
247             self.id = id
248
249 class startevent(procevent):
250     """A subclass of `procevent'. See its documentation for details."""
251     def __init__(self):
252         super().__init__(getprocid())
253
254 class finishevent(procevent):
255     """A subclass of `procevent'. Intended to be emitted when a
256     process finishes and terminates. The `aborted' field can be used
257     to indicate whether the process completed successfully, if such a
258     distinction is meaningful. The `start' parameter should be the
259     `startevent' instance used when the process was initiated."""
260     def __init__(self, start, aborted = False):
261         super().__init__(start)
262         self.aborted = aborted
263
264 sysres = staticdir()
265 itime = time.time()
266 sysres["realtime"] = simpleattr(func = lambda: time.time() - itime)
267 try:
268     import resource
269 except ImportError:
270     pass
271 else:
272     ires = resource.getrusage(resource.RUSAGE_SELF)
273     def ct():
274         ru = resource.getrusage(resource.RUSAGE_SELF)
275         return (ru.ru_utime - ires.ru_utime) + (ru.ru_stime - ires.ru_stime)
276     sysres["cputime"] = simpleattr(func = ct)
277     sysres["utime"] = simpleattr(func = lambda: resource.getrusage(resource.RUSAGE_SELF).ru_utime - ires.ru_utime)
278     sysres["stime"] = simpleattr(func = lambda: resource.getrusage(resource.RUSAGE_SELF).ru_stime - ires.ru_stime)
279     sysres["maxrss"] = simpleattr(func = lambda: resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
280     sysres["rusage"] = simpleattr(func = lambda: resource.getrusage(resource.RUSAGE_SELF))
281
282 sysinfo = staticdir()
283 sysinfo["pid"] = simpleattr(func = os.getpid)
284 sysinfo["uname"] = simpleattr(func = os.uname)
285 sysinfo["hostname"] = simpleattr(func = socket.gethostname)
286 sysinfo["platform"] = valueattr(init = sys.platform)
287
288 def reload(modname):
289     mod = sys.modules.get(modname)
290     if mod is None:
291         raise ValueError(modname)
292     import importlib
293     importlib.reload(mod)
294
295 sysctl = simplefunc(exit=lambda status=0: os._exit(status),
296                     reload=reload)