/mandos/trunk

 

locale.setlocale(locale.LC_ALL, "")

 

domain = "se.recompile"

busname = domain + ".Mandos"

server_path = "/"

 

 

def string_to_delta(interval):

 

    try:

        return rfc3339_duration_to_delta(interval)

 

 

def parse_pre_1_6_1_interval(interval):

    >>> parse_pre_1_6_1_interval('7d')

    datetime.timedelta(7)

    >>> parse_pre_1_6_1_interval('60s')

 

 

class TableOfClients(object):

        "Name": "Name",

        "Enabled": "Enabled",

        "Timeout": "Timeout",

        "LastCheckerStatus": "Last Checker Status",

    }

 

        self.clients = clients

        self.keywords = keywords

 

    def __str__(self):

        return "\n".join(self.rows())

    def row_formatting_string(self):

        "Format string used to format table rows"

        return " ".join("{{{key}:{width}}}".format(

            key=key)

 

    def string_from_client(self, client, key):

        return self.valuetostring(client[key], key)

        return str(value)

 

    def header_line(self, format_string):

 

    def client_line(self, client, format_string):

        return format_string.format(

               for key in self.keywords})

 

 

def has_actions(options):

    return any((options.enable,

                options.disable,

                options.deny))

 

 

    parser = argparse.ArgumentParser()

    parser.add_argument("--version", action="version",

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

                        help="Print all fields")

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

                        help="Dump client data in JSON format")

    parser.add_argument("-b", "--bump-timeout", action="store_true",

                        help="Bump timeout for client")

    parser.add_argument("-V", "--is-enabled", action="store_true",

                        help="Check if client is enabled")

    parser.add_argument("-r", "--remove", action="store_true",

                        help="Set extended timeout for client")

    parser.add_argument("-i", "--interval",

                        help="Set checker interval for client")

    parser.add_argument("--approval-delay",

                        help="Set delay before client approve/deny")

    parser.add_argument("--approval-duration",

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

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

                        help="Set password blob (file) for client")

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

                        help="Run self-test")

    parser.add_argument("client", nargs="*", help="Client name")

 

    if has_actions(options) and not (options.client or options.all):

        parser.error("Options require clients names or --all.")

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

    if options.all and not has_actions(options):

        parser.error("--all requires an action.")

 

    try:

        bus = dbus.SystemBus()

    mandos_serv_object_manager = dbus.Interface(

        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

 

    try:

        try:

            mandos_clients = {path: ifs_and_props[client_interface]

                              .GetManagedObjects().items()

                              if client_interface in ifs_and_props}

        finally:

    except dbus.exceptions.DBusException as e:

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

                     "\n%s", e)

    # Compile dict of (clients: properties) to process

    clients = {}

 

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

                   for path, properties in mandos_clients.items()}

    else:

            for path, client in mandos_clients.items():

                if client["Name"] == name:

                    client_objc = bus.get_object(busname, path)

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

                sys.exit(1)

 

 

 

class Test_milliseconds_to_string(unittest.TestCase):

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

                value = string_to_delta("2h")

        else:

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

 

class Test_TableOfClients(unittest.TestCase):

    def setUp(self):

            "Attr1": "X",

            "AttrTwo": "Yy",

            "AttrThree": "Zzz",

            },

        ]

    def test_short_header(self):

    def test_booleans(self):

        keywords = ["Bool", "NonDbusBoolean"]

    def test_milliseconds_detection(self):

        keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",

                    "ApprovalDuration", "ExtendedTimeout"]

An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5

0          00:00:00    00:00:01    00:00:02    00:00:03    00:00:04   

1          1T02:03:05  1T02:03:06  1T02:03:07  1T02:03:08  1T02:03:09 

    def test_empty_and_long_string_values(self):

        keywords = ["String"]

A String                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                          

A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,