/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2012-06-24 03:45:55 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 303.
  • Revision ID: teddy@recompile.se-20120624034555-7p0dtbpsz0dgsn4d
* mandos (Client.start_checker): Add comment.  Break long line.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
68
68
import binascii
69
69
import tempfile
70
70
import itertools
 
71
import collections
71
72
 
72
73
import dbus
73
74
import dbus.service
446
447
                          "fingerprint", "host", "interval",
447
448
                          "last_approval_request", "last_checked_ok",
448
449
                          "last_enabled", "name", "timeout")
449
 
    client_defaults = { "timeout": "5m",
450
 
                        "extended_timeout": "15m",
451
 
                        "interval": "2m",
 
450
    client_defaults = { "timeout": "PT5M",
 
451
                        "extended_timeout": "PT15M",
 
452
                        "interval": "PT2M",
452
453
                        "checker": "fping -q -- %%(host)s",
453
454
                        "host": "",
454
 
                        "approval_delay": "0s",
455
 
                        "approval_duration": "1s",
 
455
                        "approval_delay": "PT0S",
 
456
                        "approval_duration": "PT1S",
456
457
                        "approved_by_default": "True",
457
458
                        "enabled": "True",
458
459
                        }
716
717
            except OSError as error:
717
718
                logger.error("Failed to start subprocess",
718
719
                             exc_info=error)
 
720
                return True
719
721
            self.checker_callback_tag = (gobject.child_watch_add
720
722
                                         (self.checker.pid,
721
723
                                          self.checker_callback,
722
724
                                          data=command))
723
725
            # The checker may have completed before the gobject
724
726
            # watch was added.  Check for this.
725
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
727
            try:
 
728
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
729
            except OSError as error:
 
730
                if error.errno == errno.ECHILD:
 
731
                    # This should never happen
 
732
                    logger.error("Child process vanished",
 
733
                                 exc_info=error)
 
734
                    return True
 
735
                raise
726
736
            if pid:
727
737
                gobject.source_remove(self.checker_callback_tag)
728
738
                self.checker_callback(pid, status, command)
2090
2100
        return True
2091
2101
 
2092
2102
 
 
2103
def rfc3339_duration_to_delta(duration):
 
2104
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2105
    
 
2106
    >>> rfc3339_duration_to_delta("P7D")
 
2107
    datetime.timedelta(7)
 
2108
    >>> rfc3339_duration_to_delta("PT60S")
 
2109
    datetime.timedelta(0, 60)
 
2110
    >>> rfc3339_duration_to_delta("PT60M")
 
2111
    datetime.timedelta(0, 3600)
 
2112
    >>> rfc3339_duration_to_delta("PT24H")
 
2113
    datetime.timedelta(1)
 
2114
    >>> rfc3339_duration_to_delta("P1W")
 
2115
    datetime.timedelta(7)
 
2116
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2117
    datetime.timedelta(0, 330)
 
2118
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2119
    datetime.timedelta(1, 200)
 
2120
    """
 
2121
    
 
2122
    # Parsing an RFC 3339 duration with regular expressions is not
 
2123
    # possible - there would have to be multiple places for the same
 
2124
    # values, like seconds.  The current code, while more esoteric, is
 
2125
    # cleaner without depending on a parsing library.  If Python had a
 
2126
    # built-in library for parsing we would use it, but we'd like to
 
2127
    # avoid excessive use of external libraries.
 
2128
    
 
2129
    # New type for defining tokens, syntax, and semantics all-in-one
 
2130
    Token = collections.namedtuple("Token",
 
2131
                                   ("regexp", # To match token; if
 
2132
                                              # "value" is not None,
 
2133
                                              # must have a "group"
 
2134
                                              # containing digits
 
2135
                                    "value",  # datetime.timedelta or
 
2136
                                              # None
 
2137
                                    "followers")) # Tokens valid after
 
2138
                                                  # this token
 
2139
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2140
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2141
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2142
    token_second = Token(re.compile(r"(\d+)S"),
 
2143
                         datetime.timedelta(seconds=1),
 
2144
                         frozenset((token_end,)))
 
2145
    token_minute = Token(re.compile(r"(\d+)M"),
 
2146
                         datetime.timedelta(minutes=1),
 
2147
                         frozenset((token_second, token_end)))
 
2148
    token_hour = Token(re.compile(r"(\d+)H"),
 
2149
                       datetime.timedelta(hours=1),
 
2150
                       frozenset((token_minute, token_end)))
 
2151
    token_time = Token(re.compile(r"T"),
 
2152
                       None,
 
2153
                       frozenset((token_hour, token_minute,
 
2154
                                  token_second)))
 
2155
    token_day = Token(re.compile(r"(\d+)D"),
 
2156
                      datetime.timedelta(days=1),
 
2157
                      frozenset((token_time, token_end)))
 
2158
    token_month = Token(re.compile(r"(\d+)M"),
 
2159
                        datetime.timedelta(weeks=4),
 
2160
                        frozenset((token_day, token_end)))
 
2161
    token_year = Token(re.compile(r"(\d+)Y"),
 
2162
                       datetime.timedelta(weeks=52),
 
2163
                       frozenset((token_month, token_end)))
 
2164
    token_week = Token(re.compile(r"(\d+)W"),
 
2165
                       datetime.timedelta(weeks=1),
 
2166
                       frozenset((token_end,)))
 
2167
    token_duration = Token(re.compile(r"P"), None,
 
2168
                           frozenset((token_year, token_month,
 
2169
                                      token_day, token_time,
 
2170
                                      token_week))),
 
2171
    # Define starting values
 
2172
    value = datetime.timedelta() # Value so far
 
2173
    found_token = None
 
2174
    followers = frozenset(token_duration,) # Following valid tokens
 
2175
    s = duration                # String left to parse
 
2176
    # Loop until end token is found
 
2177
    while found_token is not token_end:
 
2178
        # Search for any currently valid tokens
 
2179
        for token in followers:
 
2180
            match = token.regexp.match(s)
 
2181
            if match is not None:
 
2182
                # Token found
 
2183
                if token.value is not None:
 
2184
                    # Value found, parse digits
 
2185
                    factor = int(match.group(1), 10)
 
2186
                    # Add to value so far
 
2187
                    value += factor * token.value
 
2188
                # Strip token from string
 
2189
                s = token.regexp.sub("", s, 1)
 
2190
                # Go to found token
 
2191
                found_token = token
 
2192
                # Set valid next tokens
 
2193
                followers = found_token.followers
 
2194
                break
 
2195
        else:
 
2196
            # No currently valid tokens were found
 
2197
            raise ValueError("Invalid RFC 3339 duration")
 
2198
    # End token found
 
2199
    return value
 
2200
 
 
2201
 
2093
2202
def string_to_delta(interval):
2094
2203
    """Parse a string and return a datetime.timedelta
2095
2204
    
2106
2215
    >>> string_to_delta('5m 30s')
2107
2216
    datetime.timedelta(0, 330)
2108
2217
    """
 
2218
    
 
2219
    try:
 
2220
        return rfc3339_duration_to_delta(interval)
 
2221
    except ValueError:
 
2222
        pass
 
2223
    
2109
2224
    timevalue = datetime.timedelta(0)
2110
2225
    for s in interval.split():
2111
2226
        try: