/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: 2015-05-31 15:56:58 UTC
  • Revision ID: teddy@recompile.se-20150531155658-l7znu7zlqr2dmuwd
mandos: Generate better messages in exceptions.

mandos (ProxyClient.__init__): Include fingerprint in KeyError().
(rfc3339_duration_to_delta): Include duration in ValueError().

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1111
1111
                interface_names.add(alt_interface)
1112
1112
                # Is this a D-Bus signal?
1113
1113
                if getattr(attribute, "_dbus_is_signal", False):
1114
 
                    if sys.version == 2:
1115
 
                        # Extract the original non-method undecorated
1116
 
                        # function by black magic
1117
 
                        nonmethod_func = (dict(
1118
 
                            zip(attribute.func_code.co_freevars,
1119
 
                                attribute.__closure__))
1120
 
                                          ["func"].cell_contents)
1121
 
                    else:
1122
 
                        nonmethod_func = attribute
 
1114
                    # Extract the original non-method undecorated
 
1115
                    # function by black magic
 
1116
                    nonmethod_func = (dict(
 
1117
                        zip(attribute.func_code.co_freevars,
 
1118
                            attribute.__closure__))
 
1119
                                      ["func"].cell_contents)
1123
1120
                    # Create a new, but exactly alike, function
1124
1121
                    # object, and decorate it to be a new D-Bus signal
1125
1122
                    # with the alternate D-Bus interface name
1126
 
                    if sys.version == 2:
1127
 
                        new_function = types.FunctionType(
1128
 
                            nonmethod_func.func_code,
1129
 
                            nonmethod_func.func_globals,
1130
 
                            nonmethod_func.func_name,
1131
 
                            nonmethod_func.func_defaults,
1132
 
                            nonmethod_func.func_closure)
1133
 
                    else:
1134
 
                        new_function = types.FunctionType(
1135
 
                            nonmethod_func.__code__,
1136
 
                            nonmethod_func.__globals__,
1137
 
                            nonmethod_func.__name__,
1138
 
                            nonmethod_func.__defaults__,
1139
 
                            nonmethod_func.__closure__)
1140
1123
                    new_function = (dbus.service.signal(
1141
 
                        alt_interface,
1142
 
                        attribute._dbus_signature)(new_function))
 
1124
                        alt_interface, attribute._dbus_signature)
 
1125
                                    (types.FunctionType(
 
1126
                                        nonmethod_func.func_code,
 
1127
                                        nonmethod_func.func_globals,
 
1128
                                        nonmethod_func.func_name,
 
1129
                                        nonmethod_func.func_defaults,
 
1130
                                        nonmethod_func.func_closure)))
1143
1131
                    # Copy annotations, if any
1144
1132
                    try:
1145
1133
                        new_function._dbus_annotations = dict(
2194
2182
    # avoid excessive use of external libraries.
2195
2183
    
2196
2184
    # New type for defining tokens, syntax, and semantics all-in-one
 
2185
    Token = collections.namedtuple("Token",
 
2186
                                   ("regexp", # To match token; if
 
2187
                                              # "value" is not None,
 
2188
                                              # must have a "group"
 
2189
                                              # containing digits
 
2190
                                    "value",  # datetime.timedelta or
 
2191
                                              # None
 
2192
                                    "followers")) # Tokens valid after
 
2193
                                                  # this token
2197
2194
    Token = collections.namedtuple("Token", (
2198
2195
        "regexp",  # To match token; if "value" is not None, must have
2199
2196
                   # a "group" containing digits
2234
2231
    # Define starting values
2235
2232
    value = datetime.timedelta() # Value so far
2236
2233
    found_token = None
2237
 
    followers = frozenset((token_duration, )) # Following valid tokens
 
2234
    followers = frozenset((token_duration,)) # Following valid tokens
2238
2235
    s = duration                # String left to parse
2239
2236
    # Loop until end token is found
2240
2237
    while found_token is not token_end: