379
367
self.server_state_changed)
380
368
self.server_state_changed(self.server.GetState())
383
370
class AvahiServiceToSyslog(AvahiService):
384
371
def rename(self):
385
372
"""Add the new name to the syslog messages"""
386
373
ret = AvahiService.rename(self)
387
374
syslogger.setFormatter(logging.Formatter
388
('Mandos ({0}) [%(process)d]:'
389
' %(levelname)s: %(message)s'
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
394
def timedelta_to_milliseconds(td):
380
def _timedelta_to_milliseconds(td):
395
381
"Convert a datetime.timedelta() to milliseconds"
396
382
return ((td.days * 24 * 60 * 60 * 1000)
397
383
+ (td.seconds * 1000)
398
384
+ (td.microseconds // 1000))
401
386
class Client(object):
402
387
"""A representation of a client host served by this server.
405
approved: bool(); 'None' if not yet approved/disapproved
390
_approved: bool(); 'None' if not yet approved/disapproved
406
391
approval_delay: datetime.timedelta(); Time to wait for approval
407
392
approval_duration: datetime.timedelta(); Duration of one approval
408
393
checker: subprocess.Popen(); a running checker process used
445
431
"created", "enabled", "fingerprint",
446
432
"host", "interval", "last_checked_ok",
447
433
"last_enabled", "name", "timeout")
448
client_defaults = { "timeout": "5m",
449
"extended_timeout": "15m",
451
"checker": "fping -q -- %%(host)s",
453
"approval_delay": "0s",
454
"approval_duration": "1s",
455
"approved_by_default": "True",
459
435
def timeout_milliseconds(self):
460
436
"Return the 'timeout' attribute in milliseconds"
461
return timedelta_to_milliseconds(self.timeout)
437
return _timedelta_to_milliseconds(self.timeout)
463
439
def extended_timeout_milliseconds(self):
464
440
"Return the 'extended_timeout' attribute in milliseconds"
465
return timedelta_to_milliseconds(self.extended_timeout)
441
return _timedelta_to_milliseconds(self.extended_timeout)
467
443
def interval_milliseconds(self):
468
444
"Return the 'interval' attribute in milliseconds"
469
return timedelta_to_milliseconds(self.interval)
445
return _timedelta_to_milliseconds(self.interval)
471
447
def approval_delay_milliseconds(self):
472
return timedelta_to_milliseconds(self.approval_delay)
475
def config_parser(config):
476
"""Construct a new dict of client settings of this form:
477
{ client_name: {setting_name: value, ...}, ...}
478
with exceptions for any special settings as defined above.
479
NOTE: Must be a pure function. Must return the same result
480
value given the same arguments.
483
for client_name in config.sections():
484
section = dict(config.items(client_name))
485
client = settings[client_name] = {}
487
client["host"] = section["host"]
488
# Reformat values from string types to Python types
489
client["approved_by_default"] = config.getboolean(
490
client_name, "approved_by_default")
491
client["enabled"] = config.getboolean(client_name,
494
client["fingerprint"] = (section["fingerprint"].upper()
496
if "secret" in section:
497
client["secret"] = section["secret"].decode("base64")
498
elif "secfile" in section:
499
with open(os.path.expanduser(os.path.expandvars
500
(section["secfile"])),
502
client["secret"] = secfile.read()
504
raise TypeError("No secret or secfile for section {0}"
506
client["timeout"] = string_to_delta(section["timeout"])
507
client["extended_timeout"] = string_to_delta(
508
section["extended_timeout"])
509
client["interval"] = string_to_delta(section["interval"])
510
client["approval_delay"] = string_to_delta(
511
section["approval_delay"])
512
client["approval_duration"] = string_to_delta(
513
section["approval_duration"])
514
client["checker_command"] = section["checker"]
515
client["last_approval_request"] = None
516
client["last_checked_ok"] = None
517
client["last_checker_status"] = -2
521
def __init__(self, settings, name = None):
448
return _timedelta_to_milliseconds(self.approval_delay)
450
def __init__(self, name = None, config=None):
451
"""Note: the 'checker' key in 'config' sets the
452
'checker_command' attribute and *not* the 'checker'
523
# adding all client settings
524
for setting, value in settings.iteritems():
525
setattr(self, setting, value)
528
if not hasattr(self, "last_enabled"):
529
self.last_enabled = datetime.datetime.utcnow()
530
if not hasattr(self, "expires"):
531
self.expires = (datetime.datetime.utcnow()
534
self.last_enabled = None
537
457
logger.debug("Creating client %r", self.name)
538
458
# Uppercase and remove spaces from fingerprint for later
539
459
# comparison purposes with return value from the fingerprint()
461
self.fingerprint = (config["fingerprint"].upper()
541
463
logger.debug(" Fingerprint: %s", self.fingerprint)
542
self.created = settings.get("created",
543
datetime.datetime.utcnow())
545
# attributes specific for this server instance
464
if "secret" in config:
465
self.secret = config["secret"].decode("base64")
466
elif "secfile" in config:
467
with open(os.path.expanduser(os.path.expandvars
468
(config["secfile"])),
470
self.secret = secfile.read()
472
raise TypeError("No secret or secfile for client %s"
474
self.host = config.get("host", "")
475
self.created = datetime.datetime.utcnow()
476
self.enabled = config.get("enabled", True)
477
self.last_approval_request = None
479
self.last_enabled = datetime.datetime.utcnow()
481
self.last_enabled = None
482
self.last_checked_ok = None
483
self.last_checker_status = None
484
self.timeout = string_to_delta(config["timeout"])
485
self.extended_timeout = string_to_delta(config
486
["extended_timeout"])
487
self.interval = string_to_delta(config["interval"])
546
488
self.checker = None
547
489
self.checker_initiator_tag = None
548
490
self.disable_initiator_tag = None
492
self.expires = datetime.datetime.utcnow() + self.timeout
549
495
self.checker_callback_tag = None
496
self.checker_command = config["checker"]
550
497
self.current_checker_command = None
498
self._approved = None
499
self.approved_by_default = config.get("approved_by_default",
552
501
self.approvals_pending = 0
502
self.approval_delay = string_to_delta(
503
config["approval_delay"])
504
self.approval_duration = string_to_delta(
505
config["approval_duration"])
553
506
self.changedstate = (multiprocessing_manager
554
507
.Condition(multiprocessing_manager
575
528
if getattr(self, "enabled", False):
576
529
# Already enabled
531
self.send_changedstate()
578
532
self.expires = datetime.datetime.utcnow() + self.timeout
579
533
self.enabled = True
580
534
self.last_enabled = datetime.datetime.utcnow()
581
535
self.init_checker()
582
self.send_changedstate()
584
537
def disable(self, quiet=True):
585
538
"""Disable this client."""
586
539
if not getattr(self, "enabled", False):
542
self.send_changedstate()
589
544
logger.info("Disabling client %s", self.name)
590
if getattr(self, "disable_initiator_tag", None) is not None:
545
if getattr(self, "disable_initiator_tag", False):
591
546
gobject.source_remove(self.disable_initiator_tag)
592
547
self.disable_initiator_tag = None
593
548
self.expires = None
594
if getattr(self, "checker_initiator_tag", None) is not None:
549
if getattr(self, "checker_initiator_tag", False):
595
550
gobject.source_remove(self.checker_initiator_tag)
596
551
self.checker_initiator_tag = None
597
552
self.stop_checker()
598
553
self.enabled = False
600
self.send_changedstate()
601
554
# Do not run this again if called by a gobject.timeout_add
639
588
logger.warning("Checker for %(name)s crashed?",
642
def checked_ok(self):
643
"""Assert that the client has been seen, alive and well."""
644
self.last_checked_ok = datetime.datetime.utcnow()
645
self.last_checker_status = 0
648
def bump_timeout(self, timeout=None):
649
"""Bump up the timeout for this client."""
591
def checked_ok(self, timeout=None):
592
"""Bump up the timeout for this client.
594
This should only be called when the client has been seen,
650
597
if timeout is None:
651
598
timeout = self.timeout
599
self.last_checked_ok = datetime.datetime.utcnow()
652
600
if self.disable_initiator_tag is not None:
653
601
gobject.source_remove(self.disable_initiator_tag)
654
self.disable_initiator_tag = None
655
602
if getattr(self, "enabled", False):
656
603
self.disable_initiator_tag = (gobject.timeout_add
657
(timedelta_to_milliseconds
604
(_timedelta_to_milliseconds
658
605
(timeout), self.disable))
659
606
self.expires = datetime.datetime.utcnow() + timeout
690
637
self.current_checker_command)
691
638
# Start a new checker if needed
692
639
if self.checker is None:
693
# Escape attributes for the shell
694
escaped_attrs = dict(
695
(attr, re.escape(unicode(getattr(self, attr))))
697
self.runtime_expansions)
699
command = self.checker_command % escaped_attrs
700
except TypeError as error:
701
logger.error('Could not format string "%s"',
702
self.checker_command, exc_info=error)
703
return True # Try again later
641
# In case checker_command has exactly one % operator
642
command = self.checker_command % self.host
644
# Escape attributes for the shell
645
escaped_attrs = dict(
647
re.escape(unicode(str(getattr(self, attr, "")),
651
self.runtime_expansions)
654
command = self.checker_command % escaped_attrs
655
except TypeError as error:
656
logger.error('Could not format string "%s":'
657
' %s', self.checker_command, error)
658
return True # Try again later
704
659
self.current_checker_command = command
706
661
logger.info("Starting checker %r for %s",
712
667
self.checker = subprocess.Popen(command,
714
669
shell=True, cwd="/")
670
self.checker_callback_tag = (gobject.child_watch_add
672
self.checker_callback,
674
# The checker may have completed before the gobject
675
# watch was added. Check for this.
676
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
678
gobject.source_remove(self.checker_callback_tag)
679
self.checker_callback(pid, status, command)
715
680
except OSError as error:
716
logger.error("Failed to start subprocess",
718
self.checker_callback_tag = (gobject.child_watch_add
720
self.checker_callback,
722
# The checker may have completed before the gobject
723
# watch was added. Check for this.
724
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
726
gobject.source_remove(self.checker_callback_tag)
727
self.checker_callback(pid, status, command)
681
logger.error("Failed to start subprocess: %s",
728
683
# Re-run this periodically if run by gobject.timeout_add
780
def dbus_interface_annotations(dbus_interface):
781
"""Decorator for marking functions returning interface annotations
785
@dbus_interface_annotations("org.example.Interface")
786
def _foo(self): # Function name does not matter
787
return {"org.freedesktop.DBus.Deprecated": "true",
788
"org.freedesktop.DBus.Property.EmitsChangedSignal":
792
func._dbus_is_interface = True
793
func._dbus_interface = dbus_interface
794
func._dbus_name = dbus_interface
799
def dbus_annotations(annotations):
800
"""Decorator to annotate D-Bus methods, signals or properties
803
@dbus_service_property("org.example.Interface", signature="b",
805
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
806
"org.freedesktop.DBus.Property."
807
"EmitsChangedSignal": "false"})
808
def Property_dbus_property(self):
809
return dbus.Boolean(False)
812
func._dbus_annotations = annotations
817
735
class DBusPropertyException(dbus.exceptions.DBusException):
818
736
"""A base class for D-Bus property-related exceptions
845
def _is_dbus_thing(thing):
846
"""Returns a function testing if an attribute is a D-Bus thing
848
If called like _is_dbus_thing("method") it returns a function
849
suitable for use as predicate to inspect.getmembers().
851
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
763
def _is_dbus_property(obj):
764
return getattr(obj, "_dbus_is_property", False)
854
def _get_all_dbus_things(self, thing):
766
def _get_all_dbus_properties(self):
855
767
"""Returns a generator of (name, attribute) pairs
857
return ((getattr(athing.__get__(self), "_dbus_name",
859
athing.__get__(self))
769
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
860
770
for cls in self.__class__.__mro__
862
inspect.getmembers(cls,
863
self._is_dbus_thing(thing)))
772
inspect.getmembers(cls, self._is_dbus_property))
865
774
def _get_dbus_property(self, interface_name, property_name):
866
775
"""Returns a bound method if one exists which is a D-Bus
953
859
e.setAttribute("access", prop._dbus_access)
955
861
for if_tag in document.getElementsByTagName("interface"):
957
862
for tag in (make_tag(document, name, prop)
959
in self._get_all_dbus_things("property")
864
in self._get_all_dbus_properties()
960
865
if prop._dbus_interface
961
866
== if_tag.getAttribute("name")):
962
867
if_tag.appendChild(tag)
963
# Add annotation tags
964
for typ in ("method", "signal", "property"):
965
for tag in if_tag.getElementsByTagName(typ):
967
for name, prop in (self.
968
_get_all_dbus_things(typ)):
969
if (name == tag.getAttribute("name")
970
and prop._dbus_interface
971
== if_tag.getAttribute("name")):
972
annots.update(getattr
976
for name, value in annots.iteritems():
977
ann_tag = document.createElement(
979
ann_tag.setAttribute("name", name)
980
ann_tag.setAttribute("value", value)
981
tag.appendChild(ann_tag)
982
# Add interface annotation tags
983
for annotation, value in dict(
984
itertools.chain.from_iterable(
985
annotations().iteritems()
986
for name, annotations in
987
self._get_all_dbus_things("interface")
988
if name == if_tag.getAttribute("name")
990
ann_tag = document.createElement("annotation")
991
ann_tag.setAttribute("name", annotation)
992
ann_tag.setAttribute("value", value)
993
if_tag.appendChild(ann_tag)
994
868
# Add the names to the return values for the
995
869
# "org.freedesktop.DBus.Properties" methods
996
870
if (if_tag.getAttribute("name")
1023
897
variant_level=variant_level)
1026
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1027
"""A class decorator; applied to a subclass of
1028
dbus.service.Object, it will add alternate D-Bus attributes with
1029
interface names according to the "alt_interface_names" mapping.
1032
@alternate_dbus_names({"org.example.Interface":
1033
"net.example.AlternateInterface"})
1034
class SampleDBusObject(dbus.service.Object):
1035
@dbus.service.method("org.example.Interface")
1036
def SampleDBusMethod():
1039
The above "SampleDBusMethod" on "SampleDBusObject" will be
1040
reachable via two interfaces: "org.example.Interface" and
1041
"net.example.AlternateInterface", the latter of which will have
1042
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1043
"true", unless "deprecate" is passed with a False value.
1045
This works for methods and signals, and also for D-Bus properties
1046
(from DBusObjectWithProperties) and interfaces (from the
1047
dbus_interface_annotations decorator).
900
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
902
"""Applied to an empty subclass of a D-Bus object, this metaclass
903
will add additional D-Bus attributes matching a certain pattern.
1050
for orig_interface_name, alt_interface_name in (
1051
alt_interface_names.iteritems()):
1053
interface_names = set()
1054
# Go though all attributes of the class
1055
for attrname, attribute in inspect.getmembers(cls):
905
def __new__(mcs, name, bases, attr):
906
# Go through all the base classes which could have D-Bus
907
# methods, signals, or properties in them
908
for base in (b for b in bases
909
if issubclass(b, dbus.service.Object)):
910
# Go though all attributes of the base class
911
for attrname, attribute in inspect.getmembers(base):
1056
912
# Ignore non-D-Bus attributes, and D-Bus attributes
1057
913
# with the wrong interface name
1058
914
if (not hasattr(attribute, "_dbus_interface")
1059
915
or not attribute._dbus_interface
1060
.startswith(orig_interface_name)):
916
.startswith("se.recompile.Mandos")):
1062
918
# Create an alternate D-Bus interface name based on
1063
919
# the current name
1064
920
alt_interface = (attribute._dbus_interface
1065
.replace(orig_interface_name,
1066
alt_interface_name))
1067
interface_names.add(alt_interface)
921
.replace("se.recompile.Mandos",
922
"se.bsnet.fukt.Mandos"))
1068
923
# Is this a D-Bus signal?
1069
924
if getattr(attribute, "_dbus_is_signal", False):
1070
925
# Extract the original non-method function by
1149
992
attribute.func_name,
1150
993
attribute.func_defaults,
1151
994
attribute.func_closure)))
1152
# Copy annotations, if any
1154
attr[attrname]._dbus_annotations = (
1155
dict(attribute._dbus_annotations))
1156
except AttributeError:
1158
# Is this a D-Bus interface?
1159
elif getattr(attribute, "_dbus_is_interface", False):
1160
# Create a new, but exactly alike, function
1161
# object. Decorate it to be a new D-Bus interface
1162
# with the alternate D-Bus interface name. Add it
1164
attr[attrname] = (dbus_interface_annotations
1167
(attribute.func_code,
1168
attribute.func_globals,
1169
attribute.func_name,
1170
attribute.func_defaults,
1171
attribute.func_closure)))
1173
# Deprecate all alternate interfaces
1174
iname="_AlternateDBusNames_interface_annotation{0}"
1175
for interface_name in interface_names:
1176
@dbus_interface_annotations(interface_name)
1178
return { "org.freedesktop.DBus.Deprecated":
1180
# Find an unused name
1181
for aname in (iname.format(i)
1182
for i in itertools.count()):
1183
if aname not in attr:
1187
# Replace the class with a new subclass of it with
1188
# methods, signals, etc. as created above.
1189
cls = type(b"{0}Alternate".format(cls.__name__),
1195
@alternate_dbus_interfaces({"se.recompile.Mandos":
1196
"se.bsnet.fukt.Mandos"})
995
return type.__new__(mcs, name, bases, attr)
1197
998
class ClientDBus(Client, DBusObjectWithProperties):
1198
999
"""A Client class using D-Bus
1260
1064
checker is not None)
1261
1065
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1262
1066
"LastCheckedOK")
1263
last_checker_status = notifychangeproperty(dbus.Int16,
1264
"LastCheckerStatus")
1265
1067
last_approval_request = notifychangeproperty(
1266
1068
datetime_to_dbus, "LastApprovalRequest")
1267
1069
approved_by_default = notifychangeproperty(dbus.Boolean,
1268
1070
"ApprovedByDefault")
1269
approval_delay = notifychangeproperty(dbus.UInt64,
1071
approval_delay = notifychangeproperty(dbus.UInt16,
1270
1072
"ApprovalDelay",
1272
timedelta_to_milliseconds)
1074
_timedelta_to_milliseconds)
1273
1075
approval_duration = notifychangeproperty(
1274
dbus.UInt64, "ApprovalDuration",
1275
type_func = timedelta_to_milliseconds)
1076
dbus.UInt16, "ApprovalDuration",
1077
type_func = _timedelta_to_milliseconds)
1276
1078
host = notifychangeproperty(dbus.String, "Host")
1277
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1079
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1279
timedelta_to_milliseconds)
1081
_timedelta_to_milliseconds)
1280
1082
extended_timeout = notifychangeproperty(
1281
dbus.UInt64, "ExtendedTimeout",
1282
type_func = timedelta_to_milliseconds)
1283
interval = notifychangeproperty(dbus.UInt64,
1083
dbus.UInt16, "ExtendedTimeout",
1084
type_func = _timedelta_to_milliseconds)
1085
interval = notifychangeproperty(dbus.UInt16,
1286
timedelta_to_milliseconds)
1088
_timedelta_to_milliseconds)
1287
1089
checker_command = notifychangeproperty(dbus.String, "Checker")
1289
1091
del notifychangeproperty
1529
1327
def Timeout_dbus_property(self, value=None):
1530
1328
if value is None: # get
1531
1329
return dbus.UInt64(self.timeout_milliseconds())
1532
old_timeout = self.timeout
1533
1330
self.timeout = datetime.timedelta(0, 0, 0, value)
1534
# Reschedule disabling
1536
now = datetime.datetime.utcnow()
1537
self.expires += self.timeout - old_timeout
1538
if self.expires <= now:
1539
# The timeout has passed
1542
if (getattr(self, "disable_initiator_tag", None)
1545
gobject.source_remove(self.disable_initiator_tag)
1546
self.disable_initiator_tag = (
1547
gobject.timeout_add(
1548
timedelta_to_milliseconds(self.expires - now),
1331
if getattr(self, "disable_initiator_tag", None) is None:
1333
# Reschedule timeout
1334
gobject.source_remove(self.disable_initiator_tag)
1335
self.disable_initiator_tag = None
1337
time_to_die = _timedelta_to_milliseconds((self
1342
if time_to_die <= 0:
1343
# The timeout has passed
1346
self.expires = (datetime.datetime.utcnow()
1347
+ datetime.timedelta(milliseconds =
1349
self.disable_initiator_tag = (gobject.timeout_add
1350
(time_to_die, self.disable))
1551
1352
# ExtendedTimeout - property
1552
1353
@dbus_service_property(_interface, signature="t",
2232
2048
stored_state_file)
2235
initlogger(debug, logging.DEBUG)
2051
initlogger(logging.DEBUG)
2237
2053
if not debuglevel:
2240
2056
level = getattr(logging, debuglevel.upper())
2241
initlogger(debug, level)
2243
2059
if server_settings["servicename"] != "Mandos":
2244
2060
syslogger.setFormatter(logging.Formatter
2245
('Mandos ({0}) [%(process)d]:'
2246
' %(levelname)s: %(message)s'
2247
.format(server_settings
2061
('Mandos (%s) [%%(process)d]:'
2062
' %%(levelname)s: %%(message)s'
2063
% server_settings["servicename"]))
2250
2065
# Parse config file with clients
2251
client_config = configparser.SafeConfigParser(Client
2066
client_defaults = { "timeout": "5m",
2067
"extended_timeout": "15m",
2069
"checker": "fping -q -- %%(host)s",
2071
"approval_delay": "0s",
2072
"approval_duration": "1s",
2074
client_config = configparser.SafeConfigParser(client_defaults)
2253
2075
client_config.read(os.path.join(server_settings["configdir"],
2254
2076
"clients.conf"))
2350
2176
client_class = Client
2352
client_class = functools.partial(ClientDBus, bus = bus)
2354
client_settings = Client.config_parser(client_config)
2178
client_class = functools.partial(ClientDBusTransitional,
2181
special_settings = {
2182
# Some settings need to be accessd by special methods;
2183
# booleans need .getboolean(), etc. Here is a list of them:
2184
"approved_by_default":
2186
client_config.getboolean(section, "approved_by_default"),
2189
client_config.getboolean(section, "enabled"),
2191
# Construct a new dict of client settings of this form:
2192
# { client_name: {setting_name: value, ...}, ...}
2193
# with exceptions for any special settings as defined above
2194
client_settings = dict((clientname,
2197
if setting not in special_settings
2198
else special_settings[setting]
2200
for setting, value in
2201
client_config.items(clientname)))
2202
for clientname in client_config.sections())
2355
2204
old_client_settings = {}
2358
2207
# Get client data and settings from last running state.
2359
2208
if server_settings["restore"]:
2389
2234
if (name != "secret" and
2390
2235
value != old_client_settings[client_name]
2392
client[name] = value
2237
setattr(client, name, value)
2393
2238
except KeyError:
2396
2241
# Clients who has passed its expire date can still be
2397
# enabled if its last checker was successful. Clients
2398
# whose checker succeeded before we stored its state is
2399
# assumed to have successfully run all checkers during
2401
if client["enabled"]:
2402
if datetime.datetime.utcnow() >= client["expires"]:
2403
if not client["last_checked_ok"]:
2405
"disabling client {0} - Client never "
2406
"performed a successful checker"
2407
.format(client_name))
2408
client["enabled"] = False
2409
elif client["last_checker_status"] != 0:
2411
"disabling client {0} - Client "
2412
"last checker failed with error code {1}"
2413
.format(client_name,
2414
client["last_checker_status"]))
2242
# enabled if its last checker was sucessful. Clients
2243
# whose checker failed before we stored its state is
2244
# assumed to have failed all checkers during downtime.
2245
if client["enabled"] and client["last_checked_ok"]:
2246
if ((datetime.datetime.utcnow()
2247
- client["last_checked_ok"])
2248
> client["interval"]):
2249
if client["last_checker_status"] != 0:
2415
2250
client["enabled"] = False
2417
2252
client["expires"] = (datetime.datetime
2419
2254
+ client["timeout"])
2420
logger.debug("Last checker succeeded,"
2421
" keeping {0} enabled"
2422
.format(client_name))
2256
client["changedstate"] = (multiprocessing_manager
2258
(multiprocessing_manager
2261
new_client = (ClientDBusTransitional.__new__
2262
(ClientDBusTransitional))
2263
tcp_server.clients[client_name] = new_client
2264
new_client.bus = bus
2265
for name, value in client.iteritems():
2266
setattr(new_client, name, value)
2267
client_object_name = unicode(client_name).translate(
2268
{ord("."): ord("_"),
2269
ord("-"): ord("_")})
2270
new_client.dbus_object_path = (dbus.ObjectPath
2272
+ client_object_name))
2273
DBusObjectWithProperties.__init__(new_client,
2278
tcp_server.clients[client_name] = (Client.__new__
2280
for name, value in client.iteritems():
2281
setattr(tcp_server.clients[client_name],
2424
client["secret"] = (
2425
pgp.decrypt(client["encrypted_secret"],
2426
client_settings[client_name]
2285
tcp_server.clients[client_name].secret = (
2286
crypt.decrypt(tcp_server.clients[client_name]
2288
client_settings[client_name]
2429
2291
# If decryption fails, we use secret from new settings
2430
logger.debug("Failed to decrypt {0} old secret"
2431
.format(client_name))
2432
client["secret"] = (
2292
tcp_server.clients[client_name].secret = (
2433
2293
client_settings[client_name]["secret"])
2435
# Add/remove clients based on new changes made to config
2436
for client_name in (set(old_client_settings)
2437
- set(client_settings)):
2438
del clients_data[client_name]
2439
for client_name in (set(client_settings)
2440
- set(old_client_settings)):
2441
clients_data[client_name] = client_settings[client_name]
2443
# Create all client objects
2444
for client_name, client in clients_data.iteritems():
2445
tcp_server.clients[client_name] = client_class(
2446
name = client_name, settings = client)
2295
# Create/remove clients based on new changes made to config
2296
for clientname in set(old_client_settings) - set(client_settings):
2297
del tcp_server.clients[clientname]
2298
for clientname in set(client_settings) - set(old_client_settings):
2299
tcp_server.clients[clientname] = (client_class(name
2448
2305
if not tcp_server.clients:
2449
2306
logger.warning("No clients defined")
2563
2414
if attr not in exclude:
2564
2415
client_dict[attr] = getattr(client, attr)
2566
clients[client.name] = client_dict
2417
clients.append(client_dict)
2567
2418
del client_settings[client.name]["secret"]
2570
with (tempfile.NamedTemporaryFile
2571
(mode='wb', suffix=".pickle", prefix='clients-',
2572
dir=os.path.dirname(stored_state_path),
2573
delete=False)) as stored_state:
2421
with os.fdopen(os.open(stored_state_path,
2422
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2423
0600), "wb") as stored_state:
2574
2424
pickle.dump((clients, client_settings), stored_state)
2575
tempname=stored_state.name
2576
os.rename(tempname, stored_state_path)
2577
2425
except (IOError, OSError) as e:
2583
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2584
logger.warning("Could not save persistent state: {0}"
2585
.format(os.strerror(e.errno)))
2587
logger.warning("Could not save persistent state:",
2426
logger.warning("Could not save persistent state: {0}"
2428
if e.errno not in (errno.ENOENT, errno.EACCES):
2591
2431
# Delete all clients, and settings from config
2592
2432
while tcp_server.clients: