84
83
properties and calls a hook function when any of them are
87
def __init__(self, proxy_object=None, *args, **kwargs):
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
88
87
self.proxy = proxy_object # Mandos Client proxy object
90
self.properties = dict()
88
self.properties = dict() if properties is None else properties
91
89
self.property_changed_match = (
92
self.proxy.connect_to_signal("PropertyChanged",
93
self.property_changed,
90
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
97
self.properties.update(
98
self.proxy.GetAll(client_interface,
99
dbus_interface = dbus.PROPERTIES_IFACE))
101
#XXX This breaks good super behaviour
102
# super(MandosClientPropertyCache, self).__init__(
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
105
def property_changed(self, property=None, value=None):
106
"""This is called whenever we get a PropertyChanged signal
107
It updates the changed property in the "properties" dict.
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
109
107
# Update properties dict with new value
110
self.properties[property] = value
108
self.properties.update(properties)
112
def delete(self, *args, **kwargs):
113
111
self.property_changed_match.remove()
114
super(MandosClientPropertyCache, self).__init__(
118
114
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
131
127
self.logger = logger
133
129
self._update_timer_callback_tag = None
134
self._update_timer_callback_lock = 0
136
131
# The widget shown normally
137
132
self._text_widget = urwid.Text("")
138
133
# The widget shown when we have focus
139
134
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
135
super(MandosClientWidget, self).__init__(**kwargs)
144
137
self.opened = False
146
last_checked_ok = isoformat_to_datetime(self.properties
149
if self.properties ["LastCheckerStatus"] != 0:
150
self.using_timer(True)
152
if self.need_approval:
153
self.using_timer(True)
155
139
self.match_objects = (
156
140
self.proxy.connect_to_signal("CheckerCompleted",
157
141
self.checker_completed,
174
158
client_interface,
175
159
byte_arrays=True))
176
#self.logger('Created client {0}'
177
# .format(self.properties["Name"]))
179
def property_changed(self, property=None, value=None):
180
super(self, MandosClientWidget).property_changed(property,
182
if property == "ApprovalPending":
183
using_timer(bool(value))
184
if property == "LastCheckerStatus":
185
using_timer(value != 0)
186
#self.logger('Checker for client {0} (command "{1}") was '
187
# ' successful'.format(self.properties["Name"],
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
190
163
def using_timer(self, flag):
191
164
"""Call this method with True or False when timer should be
192
165
activated or deactivated.
194
old = self._update_timer_callback_lock
196
self._update_timer_callback_lock += 1
198
self._update_timer_callback_lock -= 1
199
if old == 0 and self._update_timer_callback_lock:
167
if flag and self._update_timer_callback_tag is None:
200
168
# Will update the shown timer value every second
201
169
self._update_timer_callback_tag = (gobject.timeout_add
203
171
self.update_timer))
204
elif old and self._update_timer_callback_lock == 0:
172
elif not (flag or self._update_timer_callback_tag is None):
205
173
gobject.source_remove(self._update_timer_callback_tag)
206
174
self._update_timer_callback_tag = None
208
def checker_completed(self, exitstatus, condition, command):
176
def checker_completed(self, exitstatus, signal, command):
209
177
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
213
if os.WIFEXITED(condition):
214
self.logger('Checker for client {0} (command "{1}")'
215
' failed with exit code {2}'
216
.format(self.properties["Name"], command,
217
os.WEXITSTATUS(condition)))
218
elif os.WIFSIGNALED(condition):
219
self.logger('Checker for client {0} (command "{1}") was'
220
' killed by signal {2}'
221
.format(self.properties["Name"], command,
222
os.WTERMSIG(condition)))
223
elif os.WCOREDUMP(condition):
224
self.logger('Checker for client {0} (command "{1}")'
226
.format(self.properties["Name"], command))
185
self.logger('Checker for client {} (command "{}") failed'
187
.format(self.properties["Name"], command,
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
228
self.logger('Checker for client {0} completed'
195
self.logger('Checker for client {} completed'
230
197
.format(self.properties["Name"]))
233
200
def checker_started(self, command):
234
"""Server signals that a checker started. This could be useful
235
to log in the future. """
236
#self.logger('Client {0} started checker "{1}"'
237
# .format(self.properties["Name"],
201
"""Server signals that a checker started."""
202
self.logger('Client {} started checker "{}"'
203
.format(self.properties["Name"],
241
206
def got_secret(self):
242
self.logger('Client {0} received its secret'
207
self.logger('Client {} received its secret'
243
208
.format(self.properties["Name"]))
245
210
def need_approval(self, timeout, default):
247
message = 'Client {0} needs approval within {1} seconds'
212
message = 'Client {} needs approval within {} seconds'
249
message = 'Client {0} will get its secret in {1} seconds'
214
message = 'Client {} will get its secret in {} seconds'
250
215
self.logger(message.format(self.properties["Name"],
252
self.using_timer(True)
254
218
def rejected(self, reason):
255
self.logger('Client {0} was rejected; reason: {1}'
219
self.logger('Client {} was rejected; reason: {}'
256
220
.format(self.properties["Name"], reason))
258
222
def selectable(self):
295
260
last_approval_request = isoformat_to_datetime(
296
261
self.properties["LastApprovalRequest"])
297
262
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
301
267
timer = datetime.timedelta()
302
268
if self.properties["ApprovedByDefault"]:
303
message = "Approval in {0}. (d)eny?"
269
message = "Approval in {}. (d)eny?"
305
message = "Denial in {0}. (a)pprove?"
306
message = message.format(unicode(timer).rsplit(".", 1)[0])
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
307
274
elif self.properties["LastCheckerStatus"] != 0:
308
275
# When checker has failed, show timer until client expires
309
276
expires = self.properties["Expires"]
313
280
expires = (datetime.datetime.strptime
314
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
315
timer = expires - datetime.datetime.utcnow()
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
316
284
message = ('A checker has failed! Time until client'
317
' gets disabled: {0}'
318
.format(unicode(timer).rsplit(".", 1)[0]))
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
320
289
message = "enabled"
321
self._text = "{0}{1}".format(base, message)
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
323
293
if not urwid.supports_unicode():
324
294
self._text = self._text.encode("ascii", "replace")
325
295
textlist = [("normal", self._text)]
402
def property_changed(self, property=None, value=None,
404
"""Call self.update() if old value is not new value.
372
def properties_changed(self, interface, properties, invalidated):
373
"""Call self.update() if any properties changed.
405
374
This overrides the method from MandosClientPropertyCache"""
406
property_name = unicode(property)
407
old_value = self.properties.get(property_name)
408
super(MandosClientWidget, self).property_changed(
409
property=property, value=value, *args, **kwargs)
410
if self.properties.get(property_name) != old_value:
375
old_values = { key: self.properties.get(key)
376
for key in properties.keys() }
377
super(MandosClientWidget, self).properties_changed(
378
interface, properties, invalidated)
379
if any(old_values[key] != self.properties.get(key)
380
for key in old_values):
437
407
"default", "default", None),
439
"default", "default", "bold"),
409
"bold", "default", "bold"),
440
410
("underline-blink",
441
"default", "default", "underline"),
411
"underline,blink", "default", "underline,blink"),
443
"default", "default", "standout"),
413
"standout", "default", "standout"),
444
414
("bold-underline-blink",
445
"default", "default", ("bold", "underline")),
415
"bold,underline,blink", "default", "bold,underline,blink"),
446
416
("bold-standout",
447
"default", "default", ("bold", "standout")),
417
"bold,standout", "default", "bold,standout"),
448
418
("underline-blink-standout",
449
"default", "default", ("underline", "standout")),
419
"underline,blink,standout", "default",
420
"underline,blink,standout"),
450
421
("bold-underline-blink-standout",
451
"default", "default", ("bold", "underline",
422
"bold,underline,blink,standout", "default",
423
"bold,underline,blink,standout"),
455
426
if urwid.supports_unicode():
509
482
self.uilist.append(self.logbox)
510
483
self.topwidget = urwid.Pile(self.uilist)
512
def log_message(self, message):
485
def log_message(self, message, level=1):
486
"""Log message formatted with timestamp"""
487
if level < self.log_level:
513
489
timestamp = datetime.datetime.now().isoformat()
514
self.log_message_raw(timestamp + ": " + message)
490
self.log_message_raw("{}: {}".format(timestamp, message),
516
def log_message_raw(self, markup):
493
def log_message_raw(self, markup, level=1):
517
494
"""Add a log message to the log buffer."""
495
if level < self.log_level:
518
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
519
498
if (self.max_log_length
520
499
and len(self.log) > self.max_log_length):