394
394
def rename(self, remove=True):
395
395
"""Derived from the Avahi example code"""
396
396
if self.rename_count >= self.max_renames:
397
logger.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
397
log.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
400
400
raise AvahiServiceError("Too many renames")
402
402
self.server.GetAlternativeServiceName(self.name))
403
403
self.rename_count += 1
404
logger.info("Changing Zeroconf service name to %r ...",
404
log.info("Changing Zeroconf service name to %r ...",
451
451
def entry_group_state_changed(self, state, error):
452
452
"""Derived from the Avahi example code"""
453
logger.debug("Avahi entry group state change: %i", state)
453
log.debug("Avahi entry group state change: %i", state)
455
455
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
logger.debug("Zeroconf service established.")
456
log.debug("Zeroconf service established.")
457
457
elif state == avahi.ENTRY_GROUP_COLLISION:
458
logger.info("Zeroconf service name collision.")
458
log.info("Zeroconf service name collision.")
460
460
elif state == avahi.ENTRY_GROUP_FAILURE:
461
logger.critical("Avahi: Error in group state changed %s",
461
log.critical("Avahi: Error in group state changed %s",
463
463
raise AvahiGroupError("State changed: {!s}".format(error))
465
465
def cleanup(self):
495
495
except dbus.exceptions.DBusException as error:
496
496
if (error.get_dbus_name()
497
497
== "org.freedesktop.Avahi.CollisionError"):
498
logger.info("Local Zeroconf service name"
498
log.info("Local Zeroconf service name collision.")
500
499
return self.rename(remove=False)
502
logger.critical("D-Bus Exception", exc_info=error)
501
log.critical("D-Bus Exception", exc_info=error)
506
505
if error is None:
507
logger.debug("Unknown state: %r", state)
506
log.debug("Unknown state: %r", state)
509
logger.debug("Unknown state: %r: %r", state, error)
508
log.debug("Unknown state: %r: %r", state, error)
511
510
def activate(self):
512
511
"""Derived from the Avahi example code"""
574
573
certificate_type_t = ctypes.c_int
576
575
class datum_t(ctypes.Structure):
577
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
578
('size', ctypes.c_uint)]
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
580
class openpgp_crt_int(ctypes.Structure):
579
class _openpgp_crt_int(ctypes.Structure):
582
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
583
582
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
584
583
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
585
584
credentials_type_t = ctypes.c_int
594
593
# gnutls.strerror()
596
595
if message is None and code is not None:
597
message = gnutls.strerror(code)
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
598
598
return super(gnutls.Error, self).__init__(
601
601
class CertificateSecurityError(Error):
605
def __init__(self, cls):
608
def from_param(self, obj):
609
if not isinstance(obj, self.cls):
610
raise TypeError("Not of type {}: {!r}"
611
.format(self.cls.__name__, obj))
612
return ctypes.byref(obj.from_param(obj))
614
class CastToVoidPointer:
615
def __init__(self, cls):
618
def from_param(self, obj):
619
if not isinstance(obj, self.cls):
620
raise TypeError("Not of type {}: {!r}"
621
.format(self.cls.__name__, obj))
622
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
624
class With_from_param:
626
def from_param(cls, obj):
627
return obj._as_parameter_
630
class Credentials(With_from_param):
606
631
def __init__(self):
607
self._c_object = gnutls.certificate_credentials_t()
608
gnutls.certificate_allocate_credentials(
609
ctypes.byref(self._c_object))
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
610
634
self.type = gnutls.CRD_CERTIFICATE
612
636
def __del__(self):
613
gnutls.certificate_free_credentials(self._c_object)
637
gnutls.certificate_free_credentials(self)
639
class ClientSession(With_from_param):
616
640
def __init__(self, socket, credentials=None):
617
self._c_object = gnutls.session_t()
641
self._as_parameter_ = gnutls.session_t()
618
642
gnutls_flags = gnutls.CLIENT
619
643
if gnutls.check_version(b"3.5.6"):
620
644
gnutls_flags |= gnutls.NO_TICKETS
621
645
if gnutls.has_rawpk:
622
646
gnutls_flags |= gnutls.ENABLE_RAWPK
623
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
647
gnutls.init(self, gnutls_flags)
625
gnutls.set_default_priority(self._c_object)
626
gnutls.transport_set_ptr(self._c_object, socket.fileno())
627
gnutls.handshake_set_private_extensions(self._c_object,
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
629
652
self.socket = socket
630
653
if credentials is None:
631
654
credentials = gnutls.Credentials()
632
gnutls.credentials_set(self._c_object, credentials.type,
633
ctypes.cast(credentials._c_object,
655
gnutls.credentials_set(self, credentials.type,
635
657
self.credentials = credentials
637
659
def __del__(self):
638
gnutls.deinit(self._c_object)
640
662
def handshake(self):
641
return gnutls.handshake(self._c_object)
663
return gnutls.handshake(self)
643
665
def send(self, data):
644
666
data = bytes(data)
645
667
data_len = len(data)
646
668
while data_len > 0:
647
data_len -= gnutls.record_send(self._c_object,
669
data_len -= gnutls.record_send(self, data[-data_len:],
652
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
654
675
# Error handling functions
655
676
def _error_code(result):
656
677
"""A function to raise exceptions on errors, suitable
657
for the 'restype' attribute on ctypes functions"""
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
660
681
if result == gnutls.E_NO_CERTIFICATE_FOUND:
661
682
raise gnutls.CertificateSecurityError(code=result)
678
699
priority_set_direct = _library.gnutls_priority_set_direct
679
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
680
701
ctypes.POINTER(ctypes.c_char_p)]
681
702
priority_set_direct.restype = _error_code
683
704
init = _library.gnutls_init
684
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
685
706
init.restype = _error_code
687
708
set_default_priority = _library.gnutls_set_default_priority
688
set_default_priority.argtypes = [session_t]
709
set_default_priority.argtypes = [ClientSession]
689
710
set_default_priority.restype = _error_code
691
712
record_send = _library.gnutls_record_send
692
record_send.argtypes = [session_t, ctypes.c_void_p,
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
694
715
record_send.restype = ctypes.c_ssize_t
695
716
record_send.errcheck = _retry_on_error
697
718
certificate_allocate_credentials = (
698
719
_library.gnutls_certificate_allocate_credentials)
699
720
certificate_allocate_credentials.argtypes = [
700
ctypes.POINTER(certificate_credentials_t)]
721
PointerTo(Credentials)]
701
722
certificate_allocate_credentials.restype = _error_code
703
724
certificate_free_credentials = (
704
725
_library.gnutls_certificate_free_credentials)
705
certificate_free_credentials.argtypes = [
706
certificate_credentials_t]
726
certificate_free_credentials.argtypes = [Credentials]
707
727
certificate_free_credentials.restype = None
709
729
handshake_set_private_extensions = (
710
730
_library.gnutls_handshake_set_private_extensions)
711
handshake_set_private_extensions.argtypes = [session_t,
731
handshake_set_private_extensions.argtypes = [ClientSession,
713
733
handshake_set_private_extensions.restype = None
715
735
credentials_set = _library.gnutls_credentials_set
716
credentials_set.argtypes = [session_t, credentials_type_t,
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
718
738
credentials_set.restype = _error_code
720
740
strerror = _library.gnutls_strerror
739
759
global_set_log_function.restype = None
741
761
deinit = _library.gnutls_deinit
742
deinit.argtypes = [session_t]
762
deinit.argtypes = [ClientSession]
743
763
deinit.restype = None
745
765
handshake = _library.gnutls_handshake
746
handshake.argtypes = [session_t]
747
handshake.restype = _error_code
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
748
768
handshake.errcheck = _retry_on_error
750
770
transport_set_ptr = _library.gnutls_transport_set_ptr
751
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
752
772
transport_set_ptr.restype = None
754
774
bye = _library.gnutls_bye
755
bye.argtypes = [session_t, close_request_t]
756
bye.restype = _error_code
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
757
777
bye.errcheck = _retry_on_error
759
779
check_version = _library.gnutls_check_version
1054
1073
def __del__(self):
1057
def init_checker(self):
1058
# Schedule a new checker to be started an 'interval' from now,
1059
# and every interval from then on.
1076
def init_checker(self, randomize_start=False):
1077
# Schedule a new checker to be started a randomly selected
1078
# time (a fraction of 'interval') from now. This spreads out
1079
# the startup of checkers over time when the server is
1060
1081
if self.checker_initiator_tag is not None:
1061
1082
GLib.source_remove(self.checker_initiator_tag)
1083
interval_milliseconds = int(self.interval.total_seconds()
1086
delay_milliseconds = random.randrange(
1087
interval_milliseconds + 1)
1089
delay_milliseconds = interval_milliseconds
1062
1090
self.checker_initiator_tag = GLib.timeout_add(
1063
random.randrange(int(self.interval.total_seconds() * 1000
1066
# Schedule a disable() when 'timeout' has passed
1091
delay_milliseconds, self.start_checker, randomize_start)
1092
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1093
# A checker might take up to an 'interval' of time, so we can
1094
# expire at the soonest one interval after a checker was
1095
# started. Since the initial checker is delayed, the expire
1096
# time might have to be extended.
1097
now = datetime.datetime.utcnow()
1098
self.expires = now + delay + self.interval
1099
# Schedule a disable() at expire time
1067
1100
if self.disable_initiator_tag is not None:
1068
1101
GLib.source_remove(self.disable_initiator_tag)
1069
1102
self.disable_initiator_tag = GLib.timeout_add(
1070
int(self.timeout.total_seconds() * 1000), self.disable)
1071
# Also start a new checker *right now*.
1072
self.start_checker()
1103
int((self.expires - now).total_seconds() * 1000),
1074
1106
def checker_callback(self, source, condition, connection,
1086
1118
self.last_checker_status = returncode
1087
1119
self.last_checker_signal = None
1088
1120
if self.last_checker_status == 0:
1089
logger.info("Checker for %(name)s succeeded",
1121
log.info("Checker for %(name)s succeeded", vars(self))
1091
1122
self.checked_ok()
1093
logger.info("Checker for %(name)s failed", vars(self))
1124
log.info("Checker for %(name)s failed", vars(self))
1095
1126
self.last_checker_status = -1
1096
1127
self.last_checker_signal = -returncode
1097
logger.warning("Checker for %(name)s crashed?",
1128
log.warning("Checker for %(name)s crashed?", vars(self))
1101
1131
def checked_ok(self):
1148
1178
command = self.checker_command % escaped_attrs
1149
1179
except TypeError as error:
1150
logger.error('Could not format string "%s"',
1151
self.checker_command,
1180
log.error('Could not format string "%s"',
1181
self.checker_command, exc_info=error)
1153
1182
return True # Try again later
1154
1183
self.current_checker_command = command
1155
logger.info("Starting checker %r for %s", command,
1184
log.info("Starting checker %r for %s", command, self.name)
1157
1185
# We don't need to redirect stdout and stderr, since
1158
1186
# in normal mode, that is already done by daemon(),
1159
1187
# and in debug mode we don't want to. (Stdin is
1178
1206
GLib.IOChannel.unix_new(pipe[0].fileno()),
1179
1207
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1180
1208
self.checker_callback, pipe[0], command)
1209
if start_was_randomized:
1210
# We were started after a random delay; Schedule a new
1211
# checker to be started an 'interval' from now, and every
1212
# interval from then on.
1213
now = datetime.datetime.utcnow()
1214
self.checker_initiator_tag = GLib.timeout_add(
1215
int(self.interval.total_seconds() * 1000),
1217
self.expires = max(self.expires, now + self.interval)
1218
# Don't start a new checker again after same random delay
1181
1220
# Re-run this periodically if run by GLib.timeout_add
2251
2290
class ProxyClient:
2252
2291
def __init__(self, child_pipe, key_id, fpr, address):
2253
2292
self._pipe = child_pipe
2254
self._pipe.send(('init', key_id, fpr, address))
2293
self._pipe.send(("init", key_id, fpr, address))
2255
2294
if not self._pipe.recv():
2256
2295
raise KeyError(key_id or fpr)
2258
2297
def __getattribute__(self, name):
2260
2299
return super(ProxyClient, self).__getattribute__(name)
2261
self._pipe.send(('getattr', name))
2300
self._pipe.send(("getattr", name))
2262
2301
data = self._pipe.recv()
2263
if data[0] == 'data':
2302
if data[0] == "data":
2265
if data[0] == 'function':
2304
if data[0] == "function":
2267
2306
def func(*args, **kwargs):
2268
self._pipe.send(('funcall', name, args, kwargs))
2307
self._pipe.send(("funcall", name, args, kwargs))
2269
2308
return self._pipe.recv()[1]
2273
2312
def __setattr__(self, name, value):
2275
2314
return super(ProxyClient, self).__setattr__(name, value)
2276
self._pipe.send(('setattr', name, value))
2315
self._pipe.send(("setattr", name, value))
2279
2318
class ClientHandler(socketserver.BaseRequestHandler, object):
2285
2324
def handle(self):
2286
2325
with contextlib.closing(self.server.child_pipe) as child_pipe:
2287
logger.info("TCP connection from: %s",
2288
str(self.client_address))
2289
logger.debug("Pipe FD: %d",
2290
self.server.child_pipe.fileno())
2326
log.info("TCP connection from: %s",
2327
str(self.client_address))
2328
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2292
2330
session = gnutls.ClientSession(self.request)
2294
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2332
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2295
2333
# "+AES-256-CBC", "+SHA1",
2296
2334
# "+COMP-NULL", "+CTYPE-OPENPGP",
2299
2337
priority = self.server.gnutls_priority
2300
2338
if priority is None:
2301
2339
priority = "NORMAL"
2302
gnutls.priority_set_direct(session._c_object,
2303
priority.encode("utf-8"),
2340
gnutls.priority_set_direct(session,
2341
priority.encode("utf-8"), None)
2306
2343
# Start communication using the Mandos protocol
2307
2344
# Get protocol number
2308
2345
line = self.request.makefile().readline()
2309
logger.debug("Protocol version: %r", line)
2346
log.debug("Protocol version: %r", line)
2311
2348
if int(line.strip().split()[0]) > 1:
2312
2349
raise RuntimeError(line)
2313
2350
except (ValueError, IndexError, RuntimeError) as error:
2314
logger.error("Unknown protocol version: %s", error)
2351
log.error("Unknown protocol version: %s", error)
2317
2354
# Start GnuTLS connection
2319
2356
session.handshake()
2320
2357
except gnutls.Error as error:
2321
logger.warning("Handshake failed: %s", error)
2358
log.warning("Handshake failed: %s", error)
2322
2359
# Do not run session.bye() here: the session is not
2323
2360
# established. Just abandon the request.
2325
logger.debug("Handshake succeeded")
2362
log.debug("Handshake succeeded")
2327
2364
approval_required = False
2427
2464
except gnutls.Error as error:
2428
logger.warning("GnuTLS bye failed",
2465
log.warning("GnuTLS bye failed", exc_info=error)
2432
2468
def peer_certificate(session):
2433
2469
"Return the peer's certificate as a bytestring"
2435
cert_type = gnutls.certificate_type_get2(session._c_object,
2471
cert_type = gnutls.certificate_type_get2(
2472
session, gnutls.CTYPE_PEERS)
2437
2473
except AttributeError:
2438
cert_type = gnutls.certificate_type_get(session._c_object)
2474
cert_type = gnutls.certificate_type_get(session)
2439
2475
if gnutls.has_rawpk:
2440
2476
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2442
2478
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2443
2479
# If not a valid certificate type...
2444
2480
if cert_type not in valid_cert_types:
2445
logger.info("Cert type %r not in %r", cert_type,
2481
log.info("Cert type %r not in %r", cert_type,
2447
2483
# ...return invalid data
2449
2485
list_size = ctypes.c_uint(1)
2450
2486
cert_list = (gnutls.certificate_get_peers
2451
(session._c_object, ctypes.byref(list_size)))
2487
(session, ctypes.byref(list_size)))
2452
2488
if not bool(cert_list) and list_size.value != 0:
2453
2489
raise gnutls.Error("error getting peer certificate")
2454
2490
if list_size.value == 0:
2633
2669
(self.interface + "\0").encode("utf-8"))
2634
2670
except socket.error as error:
2635
2671
if error.errno == errno.EPERM:
2636
logger.error("No permission to bind to"
2637
" interface %s", self.interface)
2672
log.error("No permission to bind to interface %s",
2638
2674
elif error.errno == errno.ENOPROTOOPT:
2639
logger.error("SO_BINDTODEVICE not available;"
2640
" cannot bind to interface %s",
2675
log.error("SO_BINDTODEVICE not available; cannot"
2676
" bind to interface %s", self.interface)
2642
2677
elif error.errno == errno.ENODEV:
2643
logger.error("Interface %s does not exist,"
2644
" cannot bind", self.interface)
2678
log.error("Interface %s does not exist, cannot"
2679
" bind", self.interface)
2647
2682
# Only bind(2) the socket if we really need to.
2762
2797
# remove the old hook in favor of the new above hook on
2765
if command == 'funcall':
2800
if command == "funcall":
2766
2801
funcname = request[1]
2767
2802
args = request[2]
2768
2803
kwargs = request[3]
2770
parent_pipe.send(('data', getattr(client_object,
2805
parent_pipe.send(("data", getattr(client_object,
2771
2806
funcname)(*args,
2774
if command == 'getattr':
2809
if command == "getattr":
2775
2810
attrname = request[1]
2776
2811
if isinstance(client_object.__getattribute__(attrname),
2777
2812
collections.abc.Callable):
2778
parent_pipe.send(('function', ))
2813
parent_pipe.send(("function", ))
2780
2815
parent_pipe.send((
2781
'data', client_object.__getattribute__(attrname)))
2816
"data", client_object.__getattribute__(attrname)))
2783
if command == 'setattr':
2818
if command == "setattr":
2784
2819
attrname = request[1]
2785
2820
value = request[2]
2786
2821
setattr(client_object, attrname, value)
2892
2927
def string_to_delta(interval):
2893
2928
"""Parse a string and return a datetime.timedelta
2895
>>> string_to_delta('7d') == datetime.timedelta(7)
2897
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2899
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2901
>>> string_to_delta('24h') == datetime.timedelta(1)
2903
>>> string_to_delta('1w') == datetime.timedelta(7)
2905
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2930
>>> string_to_delta("7d") == datetime.timedelta(7)
2932
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2934
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2936
>>> string_to_delta("24h") == datetime.timedelta(1)
2938
>>> string_to_delta("1w") == datetime.timedelta(7)
2940
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
3305
3339
os.remove(stored_state_path)
3306
3340
except IOError as e:
3307
3341
if e.errno == errno.ENOENT:
3308
logger.warning("Could not load persistent state:"
3309
" {}".format(os.strerror(e.errno)))
3342
log.warning("Could not load persistent state:"
3343
" %s", os.strerror(e.errno))
3311
logger.critical("Could not load persistent state:",
3345
log.critical("Could not load persistent state:",
3314
3348
except EOFError as e:
3315
logger.warning("Could not load persistent state: "
3349
log.warning("Could not load persistent state: EOFError:",
3319
3352
with PGPEngine() as pgp:
3320
3353
for client_name, client in clients_data.items():
3347
3380
if client["enabled"]:
3348
3381
if datetime.datetime.utcnow() >= client["expires"]:
3349
3382
if not client["last_checked_ok"]:
3351
"disabling client {} - Client never "
3352
"performed a successful checker".format(
3383
log.warning("disabling client %s - Client"
3384
" never performed a successful"
3385
" checker", client_name)
3354
3386
client["enabled"] = False
3355
3387
elif client["last_checker_status"] != 0:
3357
"disabling client {} - Client last"
3358
" checker failed with error code"
3361
client["last_checker_status"]))
3388
log.warning("disabling client %s - Client"
3389
" last checker failed with error"
3390
" code %s", client_name,
3391
client["last_checker_status"])
3362
3392
client["enabled"] = False
3364
3394
client["expires"] = (
3365
3395
datetime.datetime.utcnow()
3366
3396
+ client["timeout"])
3367
logger.debug("Last checker succeeded,"
3368
" keeping {} enabled".format(
3397
log.debug("Last checker succeeded, keeping %s"
3398
" enabled", client_name)
3371
3400
client["secret"] = pgp.decrypt(
3372
3401
client["encrypted_secret"],
3373
3402
client_settings[client_name]["secret"])
3374
3403
except PGPError:
3375
3404
# If decryption fails, we use secret from new settings
3376
logger.debug("Failed to decrypt {} old secret".format(
3405
log.debug("Failed to decrypt %s old secret",
3378
3407
client["secret"] = (client_settings[client_name]
3613
3642
service.port = tcp_server.socket.getsockname()[1]
3615
logger.info("Now listening on address %r, port %d,"
3616
" flowinfo %d, scope_id %d",
3617
*tcp_server.socket.getsockname())
3644
log.info("Now listening on address %r, port %d, flowinfo %d,"
3645
" scope_id %d", *tcp_server.socket.getsockname())
3619
logger.info("Now listening on address %r, port %d",
3620
*tcp_server.socket.getsockname())
3647
log.info("Now listening on address %r, port %d",
3648
*tcp_server.socket.getsockname())
3622
3650
# service.interface = tcp_server.socket.getsockname()[3]
3638
3666
lambda *args, **kwargs: (tcp_server.handle_request
3639
3667
(*args[2:], **kwargs) or True))
3641
logger.debug("Starting main loop")
3669
log.debug("Starting main loop")
3642
3670
main_loop.run()
3643
3671
except AvahiError as error:
3644
logger.critical("Avahi Error", exc_info=error)
3672
log.critical("Avahi Error", exc_info=error)
3647
3675
except KeyboardInterrupt:
3649
3677
print("", file=sys.stderr)
3650
logger.debug("Server received KeyboardInterrupt")
3651
logger.debug("Server exiting")
3678
log.debug("Server received KeyboardInterrupt")
3679
log.debug("Server exiting")
3652
3680
# Must run before the D-Bus bus name gets deregistered
3656
def should_only_run_tests():
3684
def parse_test_args():
3685
# type: () -> argparse.Namespace
3657
3686
parser = argparse.ArgumentParser(add_help=False)
3658
parser.add_argument("--check", action='store_true')
3687
parser.add_argument("--check", action="store_true")
3688
parser.add_argument("--prefix", )
3659
3689
args, unknown_args = parser.parse_known_args()
3660
run_tests = args.check
3662
# Remove --check argument from sys.argv
3691
# Remove test options from sys.argv
3663
3692
sys.argv[1:] = unknown_args
3666
3695
# Add all tests from doctest strings
3667
3696
def load_tests(loader, tests, none):
3669
3698
tests.addTests(doctest.DocTestSuite())
3672
if __name__ == '__main__':
3701
if __name__ == "__main__":
3702
options = parse_test_args()
3674
if should_only_run_tests():
3675
# Call using ./mandos --check [--verbose]
3705
extra_test_prefix = options.prefix
3706
if extra_test_prefix is not None:
3707
if not (unittest.main(argv=[""], exit=False)
3708
.result.wasSuccessful()):
3710
class ExtraTestLoader(unittest.TestLoader):
3711
testMethodPrefix = extra_test_prefix
3712
# Call using ./scriptname --test [--verbose]
3713
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3715
unittest.main(argv=[""])
3680
3719
logging.shutdown()
3723
# (lambda (&optional extra)
3724
# (if (not (funcall run-tests-in-test-buffer default-directory
3726
# (funcall show-test-buffer-in-test-window)
3727
# (funcall remove-test-window)
3728
# (if extra (message "Extra tests run successfully!"))))
3729
# run-tests-in-test-buffer:
3730
# (lambda (dir &optional extra)
3731
# (with-current-buffer (get-buffer-create "*Test*")
3732
# (setq buffer-read-only nil
3733
# default-directory dir)
3735
# (compilation-mode))
3736
# (let ((process-result
3737
# (let ((inhibit-read-only t))
3738
# (process-file-shell-command
3739
# (funcall get-command-line extra) nil "*Test*"))))
3740
# (and (numberp process-result)
3741
# (= process-result 0))))
3743
# (lambda (&optional extra)
3744
# (let ((quoted-script
3745
# (shell-quote-argument (funcall get-script-name))))
3747
# (concat "%s --check" (if extra " --prefix=atest" ""))
3751
# (if (fboundp 'file-local-name)
3752
# (file-local-name (buffer-file-name))
3753
# (or (file-remote-p (buffer-file-name) 'localname)
3754
# (buffer-file-name))))
3755
# remove-test-window:
3757
# (let ((test-window (get-buffer-window "*Test*")))
3758
# (if test-window (delete-window test-window))))
3759
# show-test-buffer-in-test-window:
3761
# (when (not (get-buffer-window-list "*Test*"))
3762
# (setq next-error-last-buffer (get-buffer "*Test*"))
3763
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3764
# (display-buffer-overriding-action
3765
# `((display-buffer-in-side-window) (side . ,side)
3766
# (window-height . fit-window-to-buffer)
3767
# (window-width . fit-window-to-buffer))))
3768
# (display-buffer "*Test*"))))
3771
# (let* ((run-extra-tests (lambda () (interactive)
3772
# (funcall run-tests t)))
3773
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3774
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3775
# (setq minor-mode-overriding-map-alist
3776
# (cons `(run-tests . ,outer-keymap)
3777
# minor-mode-overriding-map-alist)))
3778
# (add-hook 'after-save-hook run-tests 90 t))