/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2014-07-25 23:32:04 UTC
  • mto: This revision was merged to the branch mainline in revision 724.
  • Revision ID: teddy@recompile.se-20140725233204-arvlsqrpfkfcwo10
Use the new auto-numbered "{}" syntax for the .format() string method.

* mandos (AvahiService.entry_group_state_changed): Use auto-numbering
                                                   for .format().
  (AvahiServiceToSyslog.rename): - '' -
  (Client.config_parser): - '' -
  (dbus_service_property): - '' -
  (DBusObjectWithProperties._is_dbus_thing): - '' -
  (DBusObjectWithProperties.Set): - '' -
  (alternate_dbus_interfaces/wrapper): - '' -
  (ClientDBus.notifychangeproperty): - '' -
  (string_to_delta): - '' -
  (daemon): - '' -
  (main): - '' -
  (main/cleanup): - '' -
* mandos-ctl (milliseconds_to_string): - '' -
  (main): - '' -
* mandos-monitor (MandosClientWidget.__init__): - '' -
  (MandosClientWidget.checker_completed): - '' -
  (MandosClientWidget.update): - '' -
  (UserInterface.client_not_found): - '' -
  (UserInterface.log_message): - '' -
  (UserInterface.toggle_log_display): - '' -
  (UserInterface.change_log_display): - '' -
  (UserInterface.find_and_remove_client): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
338
338
        elif state == avahi.ENTRY_GROUP_FAILURE:
339
339
            logger.critical("Avahi: Error in group state changed %s",
340
340
                            unicode(error))
341
 
            raise AvahiGroupError("State changed: {0!s}"
 
341
            raise AvahiGroupError("State changed: {!s}"
342
342
                                  .format(error))
343
343
    
344
344
    def cleanup(self):
395
395
        """Add the new name to the syslog messages"""
396
396
        ret = AvahiService.rename(self)
397
397
        syslogger.setFormatter(logging.Formatter
398
 
                               ('Mandos ({0}) [%(process)d]:'
 
398
                               ('Mandos ({}) [%(process)d]:'
399
399
                                ' %(levelname)s: %(message)s'
400
400
                                .format(self.name)))
401
401
        return ret
513
513
                          "rb") as secfile:
514
514
                    client["secret"] = secfile.read()
515
515
            else:
516
 
                raise TypeError("No secret or secfile for section {0}"
 
516
                raise TypeError("No secret or secfile for section {}"
517
517
                                .format(section))
518
518
            client["timeout"] = string_to_delta(section["timeout"])
519
519
            client["extended_timeout"] = string_to_delta(
797
797
    # "Set" method, so we fail early here:
798
798
    if byte_arrays and signature != "ay":
799
799
        raise ValueError("Byte arrays not supported for non-'ay'"
800
 
                         " signature {0!r}".format(signature))
 
800
                         " signature {!r}".format(signature))
801
801
    def decorator(func):
802
802
        func._dbus_is_property = True
803
803
        func._dbus_interface = dbus_interface
882
882
        If called like _is_dbus_thing("method") it returns a function
883
883
        suitable for use as predicate to inspect.getmembers().
884
884
        """
885
 
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
 
885
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
886
886
                                   False)
887
887
    
888
888
    def _get_all_dbus_things(self, thing):
938
938
            # signatures other than "ay".
939
939
            if prop._dbus_signature != "ay":
940
940
                raise ValueError("Byte arrays not supported for non-"
941
 
                                 "'ay' signature {0!r}"
 
941
                                 "'ay' signature {!r}"
942
942
                                 .format(prop._dbus_signature))
943
943
            value = dbus.ByteArray(b''.join(chr(byte)
944
944
                                            for byte in value))
1207
1207
                                        attribute.func_closure)))
1208
1208
            if deprecate:
1209
1209
                # Deprecate all alternate interfaces
1210
 
                iname="_AlternateDBusNames_interface_annotation{0}"
 
1210
                iname="_AlternateDBusNames_interface_annotation{}"
1211
1211
                for interface_name in interface_names:
1212
1212
                    @dbus_interface_annotations(interface_name)
1213
1213
                    def func(self):
1222
1222
            if interface_names:
1223
1223
                # Replace the class with a new subclass of it with
1224
1224
                # methods, signals, etc. as created above.
1225
 
                cls = type(b"{0}Alternate".format(cls.__name__),
 
1225
                cls = type(b"{}Alternate".format(cls.__name__),
1226
1226
                           (cls,), attr)
1227
1227
        return cls
1228
1228
    return wrapper
1269
1269
                   to the D-Bus.  Default: no transform
1270
1270
        variant_level: D-Bus variant level.  Default: 1
1271
1271
        """
1272
 
        attrname = "_{0}".format(dbus_name)
 
1272
        attrname = "_{}".format(dbus_name)
1273
1273
        def setter(self, value):
1274
1274
            if hasattr(self, "dbus_object_path"):
1275
1275
                if (not hasattr(self, attrname) or
2258
2258
            elif suffix == "w":
2259
2259
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2260
2260
            else:
2261
 
                raise ValueError("Unknown suffix {0!r}"
 
2261
                raise ValueError("Unknown suffix {!r}"
2262
2262
                                 .format(suffix))
2263
2263
        except IndexError as e:
2264
2264
            raise ValueError(*(e.args))
2281
2281
        # Close all standard open file descriptors
2282
2282
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2283
2283
        if not stat.S_ISCHR(os.fstat(null).st_mode):
2284
 
            raise OSError(errno.ENODEV,
2285
 
                          "{0} not a character device"
 
2284
            raise OSError(errno.ENODEV, "{} not a character device"
2286
2285
                          .format(os.devnull))
2287
2286
        os.dup2(null, sys.stdin.fileno())
2288
2287
        os.dup2(null, sys.stdout.fileno())
2298
2297
    
2299
2298
    parser = argparse.ArgumentParser()
2300
2299
    parser.add_argument("-v", "--version", action="version",
2301
 
                        version = "%(prog)s {0}".format(version),
 
2300
                        version = "%(prog)s {}".format(version),
2302
2301
                        help="show version number and exit")
2303
2302
    parser.add_argument("-i", "--interface", metavar="IF",
2304
2303
                        help="Bind to interface IF")
2443
2442
    
2444
2443
    if server_settings["servicename"] != "Mandos":
2445
2444
        syslogger.setFormatter(logging.Formatter
2446
 
                               ('Mandos ({0}) [%(process)d]:'
 
2445
                               ('Mandos ({}) [%(process)d]:'
2447
2446
                                ' %(levelname)s: %(message)s'
2448
2447
                                .format(server_settings
2449
2448
                                        ["servicename"])))
2583
2582
            os.remove(stored_state_path)
2584
2583
        except IOError as e:
2585
2584
            if e.errno == errno.ENOENT:
2586
 
                logger.warning("Could not load persistent state: {0}"
 
2585
                logger.warning("Could not load persistent state: {}"
2587
2586
                                .format(os.strerror(e.errno)))
2588
2587
            else:
2589
2588
                logger.critical("Could not load persistent state:",
2625
2624
                if datetime.datetime.utcnow() >= client["expires"]:
2626
2625
                    if not client["last_checked_ok"]:
2627
2626
                        logger.warning(
2628
 
                            "disabling client {0} - Client never "
 
2627
                            "disabling client {} - Client never "
2629
2628
                            "performed a successful checker"
2630
2629
                            .format(client_name))
2631
2630
                        client["enabled"] = False
2632
2631
                    elif client["last_checker_status"] != 0:
2633
2632
                        logger.warning(
2634
 
                            "disabling client {0} - Client "
2635
 
                            "last checker failed with error code {1}"
 
2633
                            "disabling client {} - Client last"
 
2634
                            " checker failed with error code {}"
2636
2635
                            .format(client_name,
2637
2636
                                    client["last_checker_status"]))
2638
2637
                        client["enabled"] = False
2641
2640
                                             .utcnow()
2642
2641
                                             + client["timeout"])
2643
2642
                        logger.debug("Last checker succeeded,"
2644
 
                                     " keeping {0} enabled"
 
2643
                                     " keeping {} enabled"
2645
2644
                                     .format(client_name))
2646
2645
            try:
2647
2646
                client["secret"] = (
2650
2649
                                ["secret"]))
2651
2650
            except PGPError:
2652
2651
                # If decryption fails, we use secret from new settings
2653
 
                logger.debug("Failed to decrypt {0} old secret"
 
2652
                logger.debug("Failed to decrypt {} old secret"
2654
2653
                             .format(client_name))
2655
2654
                client["secret"] = (
2656
2655
                    client_settings[client_name]["secret"])
2804
2803
                except NameError:
2805
2804
                    pass
2806
2805
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2807
 
                logger.warning("Could not save persistent state: {0}"
 
2806
                logger.warning("Could not save persistent state: {}"
2808
2807
                               .format(os.strerror(e.errno)))
2809
2808
            else:
2810
2809
                logger.warning("Could not save persistent state:",