/mandos/trunk

# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-

#

#

# Copyright © 2008-2019 Teddy Hogeborn

# Copyright © 2008-2019 Björn Påhlsson

#

# This file is part of Mandos.

#

# Mandos is free software: you can redistribute it and/or modify it

# under the terms of the GNU General Public License as published by

#     Mandos is distributed in the hope that it will be useful, but

#     WITHOUT ANY WARRANTY; without even the implied warranty of

#

# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.

#

#

try:

    from future_builtins import *

except ImportError:

    pass

import json

import unittest

import logging

# Show warnings by default

if not sys.warnoptions:

    import warnings

    warnings.simplefilter("default")

 

log = logging.getLogger(sys.argv[0])

logging.basicConfig(level="INFO", # Show info level messages

                    format="%(message)s") # Show basic log messages

 

logging.captureWarnings(True)   # Show warnings via the logging system

 

if sys.version_info.major == 2:

    str = unicode

 

    "KeyID": "Key ID",

    "ExtendedTimeout": "Extended Timeout",

    "Expires": "Expires",

    "LastCheckerStatus": "Last Checker Status",

}

version = "1.8.3"

 

 

try:

    dbus.OBJECT_MANAGER_IFACE

except AttributeError:

    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

 

            .format(days="{}T".format(td.days) if td.days else "",

                    hours=td.seconds // 3600,

                    minutes=(td.seconds % 3600) // 60,

                    seconds=td.seconds % 60))

 

    >>> rfc3339_duration_to_delta("P60M")

    datetime.timedelta(1680)

    >>> # Can not be empty:

    >>> rfc3339_duration_to_delta("")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u''

    >>> # Must start with "P":

    >>> rfc3339_duration_to_delta("1D")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u'1D'

    >>> # Must use correct order

    >>> rfc3339_duration_to_delta("PT1S2M")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u'PT1S2M'

    >>> # Time needs time marker

    >>> rfc3339_duration_to_delta("P1H2S")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u'P1H2S'

    >>> # Weeks can not be combined with anything else

    >>> rfc3339_duration_to_delta("P1D2W")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u'P1D2W'

    >>> rfc3339_duration_to_delta("P2W2H")

    Traceback (most recent call last):

    ...

    ValueError: Invalid RFC 3339 duration: u'P2W2H'

 

 

    Token = collections.namedtuple("Token", (

        "regexp",  # To match token; if "value" is not None, must have

                   # a "group" containing digits

        "value",   # datetime.timedelta or None

        "followers"))           # Tokens valid after this token

                         frozenset((token_end, )))

                       frozenset((token_end, )))

                                      token_week)))

    # Define starting values:

    # Value so far

    value = datetime.timedelta()

    # Following valid tokens

    followers = frozenset((token_duration, ))

    # String left to parse

    s = duration

            raise ValueError("Invalid RFC 3339 duration: {!r}"

                             .format(duration))

    """

 

    try:

        return rfc3339_duration_to_delta(interval)

    except ValueError as e:

        log.warning("%s - Parsing as pre-1.6.1 interval instead",

                    ' '.join(e.args))

    return parse_pre_1_6_1_interval(interval)

 

 

def parse_pre_1_6_1_interval(interval):

    """Parse an interval string as documented by Mandos before 1.6.1, and

    return a datetime.timedelta

    >>> parse_pre_1_6_1_interval('7d')

    >>> parse_pre_1_6_1_interval('60s')

    >>> parse_pre_1_6_1_interval('60m')

    >>> parse_pre_1_6_1_interval('24h')

    >>> parse_pre_1_6_1_interval('1w')

    >>> parse_pre_1_6_1_interval('5m 30s')

    >>> parse_pre_1_6_1_interval('')

    datetime.timedelta(0)

    >>> # Ignore unknown characters, allow any order and repetitions

    >>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')

    datetime.timedelta(2, 480, 18000)

 

 

 

 

        if isinstance(value, dbus.Boolean):

        return str(value)

 

        width=max(len(tablewords[key]),

                  max(len(valuetostring(client[key], key))

                      for client in clients)),

        key=key)

                             for key in keywords)

        print(format_string

              .format(**{key: valuetostring(client[key], key)

                         for key in keywords}))

 

 

                        version="%(prog)s {}".format(version),

    parser.add_argument("-j", "--dump-json", action="store_true",

                        help="Dump client data in JSON format")

    parser.add_argument("-s", "--secret",

                        type=argparse.FileType(mode="rb"),

 

        parser.error("--verbose can only be used alone.")

    if options.dump_json and (options.verbose

                              or has_actions(options)):

        parser.error("--dump-json can only be used alone.")

        log.critical("Could not connect to Mandos server")

 

                                 dbus_interface=server_interface)

    mandos_serv_object_manager = dbus.Interface(

        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

 

    # block stderr since dbus library prints to stderr

            mandos_clients = {path: ifs_and_props[client_interface]

                              for path, ifs_and_props in

                              mandos_serv_object_manager

                              .GetManagedObjects().items()

                              if client_interface in ifs_and_props}

            # restore stderr

    except dbus.exceptions.DBusException as e:

        log.critical("Failed to access Mandos server through D-Bus:"

                     "\n%s", e)

 

    clients = {}

 

        clients = {bus.get_object(busname, path): properties

                   for path, properties in mandos_clients.items()}

            for path, client in mandos_clients.items():

                log.critical("Client not found on server: %r", name)

 

        if options.verbose or options.dump_json:

            keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",

                        "Created", "Interval", "Host", "KeyID",

                        "Fingerprint", "CheckerRunning",

                        "ApprovedByDefault", "LastApprovalRequest",

                        "ApprovalDelay", "ApprovalDuration",

                        "Checker", "ExtendedTimeout", "Expires",

                        "LastCheckerStatus")

 

        if options.dump_json:

            json.dump({client["Name"]: {key:

                                        bool(client[key])

                                        if isinstance(client[key],

                                                      dbus.Boolean)

                                        else client[key]

                                        for key in keywords}

                       for client in clients.values()},

                      fp=sys.stdout, indent=4,

                      separators=(',', ': '))

            print()

        else:

            print_clients(clients.values(), keywords)

 

 

                                string_to_delta(value).total_seconds()

                                * 1000)

 

                if client.Get(client_interface, "Enabled",

                              dbus_interface=dbus.PROPERTIES_IFACE):

                    sys.exit(0)

                else:

                    sys.exit(1)

 

class Test_milliseconds_to_string(unittest.TestCase):

    def test_all(self):

        self.assertEqual(milliseconds_to_string(93785000),

                         "1T02:03:05")

    def test_no_days(self):

        self.assertEqual(milliseconds_to_string(7385000), "02:03:05")

    def test_all_zero(self):

        self.assertEqual(milliseconds_to_string(0), "00:00:00")

    def test_no_fractional_seconds(self):

        self.assertEqual(milliseconds_to_string(400), "00:00:00")

        self.assertEqual(milliseconds_to_string(900), "00:00:00")

        self.assertEqual(milliseconds_to_string(1900), "00:00:01")

 

class Test_string_to_delta(unittest.TestCase):

    def test_handles_basic_rfc3339(self):

        self.assertEqual(string_to_delta("PT2H"),

                         datetime.timedelta(0, 7200))

    def test_falls_back_to_pre_1_6_1_with_warning(self):

        # assertLogs only exists in Python 3.4

        if hasattr(self, "assertLogs"):

            with self.assertLogs(log, logging.WARNING):

                value = string_to_delta("2h")

        else:

            value = string_to_delta("2h")

        self.assertEqual(value, datetime.timedelta(0, 7200))

 

 

def should_only_run_tests():

    parser = argparse.ArgumentParser(add_help=False)

    parser.add_argument("--check", action='store_true')

    args, unknown_args = parser.parse_known_args()

    run_tests = args.check

    if run_tests:

        # Remove --check argument from sys.argv

        sys.argv[1:] = unknown_args

    return run_tests

 

# Add all tests from doctest strings

def load_tests(loader, tests, none):

    import doctest

    tests.addTests(doctest.DocTestSuite())

    return tests

 

    if should_only_run_tests():

        # Call using ./tdd-python-script --check [--verbose]

        unittest.main()

    else:

        main()