<h2>Editing File: /usr/lib/python3.6/site-packages/isc/eventlist.py</h2><form method='post'><textarea name='content' class='file-edit'>############################################################################
# Copyright (C) Internet Systems Consortium, Inc. (&quot;ISC&quot;)
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, you can obtain one at https://mozilla.org/MPL/2.0/.
#
# See the COPYRIGHT file distributed with this work for additional
# information regarding copyright ownership.
############################################################################

from collections import defaultdict
from .dnskey import *
from .keydict import *
from .keyevent import *


class eventlist:
    _K = defaultdict(lambda: defaultdict(list))
    _Z = defaultdict(lambda: defaultdict(list))
    _zones = set()
    _kdict = None

    def __init__(self, kdict):
        properties = [&quot;SyncPublish&quot;, &quot;Publish&quot;, &quot;SyncDelete&quot;,
                      &quot;Activate&quot;, &quot;Inactive&quot;, &quot;Delete&quot;]
        self._kdict = kdict
        for zone in kdict.zones():
            self._zones.add(zone)
            for alg, keys in kdict[zone].items():
                for k in keys.values():
                    for prop in properties:
                        t = k.gettime(prop)
                        if not t:
                            continue
                        e = keyevent(prop, k, t)
                        if k.sep:
                            self._K[zone][alg].append(e)
                        else:
                            self._Z[zone][alg].append(e)

                self._K[zone][alg] = sorted(self._K[zone][alg],
                                            key=lambda event: event.when)
                self._Z[zone][alg] = sorted(self._Z[zone][alg],
                                            key=lambda event: event.when)

    # scan events per zone, algorithm, and key type, in order of
    # occurrence, noting inconsistent states when found
    def coverage(self, zone, keytype, until, output = None):
        def noop(*args, **kwargs): pass
        if not output:
            output = noop

        no_zsk = True if (keytype and keytype == &quot;KSK&quot;) else False
        no_ksk = True if (keytype and keytype == &quot;ZSK&quot;) else False
        kok = zok = True
        found = False

        if zone and not zone in self._zones:
            output(&quot;ERROR: No key events found for %s&quot; % zone)
            return False

        if zone:
            found = True
            if not no_ksk:
                kok = self.checkzone(zone, &quot;KSK&quot;, until, output)
            if not no_zsk:
                zok = self.checkzone(zone, &quot;ZSK&quot;, until, output)
        else:
            for z in self._zones:
                if not no_ksk and z in self._K.keys():
                    found = True
                    kok = self.checkzone(z, &quot;KSK&quot;, until, output)
                if not no_zsk and z in self._Z.keys():
                    found = True
                    zok = self.checkzone(z, &quot;ZSK&quot;, until, output)

        if not found:
            output(&quot;ERROR: No key events found&quot;)
            return False

        return (kok and zok)

    def checkzone(self, zone, keytype, until, output):
        allok = True
        if keytype == &quot;KSK&quot;:
            kz = self._K[zone]
        else:
            kz = self._Z[zone]

        for alg in kz.keys():
            output(&quot;Checking scheduled %s events for zone %s, &quot;
                   &quot;algorithm %s...&quot; %
                   (keytype, zone, dnskey.algstr(alg)))
            ok = eventlist.checkset(kz[alg], keytype, until, output)
            if ok:
                output(&quot;No errors found&quot;)
            allok = allok and ok

        return allok

    @staticmethod
    def showset(eventset, output):
        if not eventset:
            return
        output(&quot;  &quot; + eventset[0].showtime() + &quot;:&quot;, skip=False)
        for event in eventset:
            output(&quot;    %s: %s&quot; % (event.what, repr(event.key)), skip=False)

    @staticmethod
    def checkset(eventset, keytype, until, output):
        groups = list()
        group = list()

        # collect up all events that have the same time
        eventsfound = False
        for event in eventset:
            # we found an event
            eventsfound = True

            # add event to current group
            if (not group or group[0].when == event.when):
                group.append(event)

            # if we're at the end of the list, we're done.  if
            # we've found an event with a later time, start a new group
            if (group[0].when != event.when):
                groups.append(group)
                group = list()
                group.append(event)

        if group:
            groups.append(group)

        if not eventsfound:
            output(&quot;ERROR: No %s events found&quot; % keytype)
            return False

        active = published = None
        for group in groups:
            if (until and calendar.timegm(group[0].when) &gt; until):
                output(&quot;Ignoring events after %s&quot; %
                      time.strftime(&quot;%a %b %d %H:%M:%S UTC %Y&quot;, 
                          time.gmtime(until)))
                return True

            for event in group:
                (active, published) = event.status(active, published)

            eventlist.showset(group, output)

            # and then check for inconsistencies:
            if not active:
                output(&quot;ERROR: No %s's are active after this event&quot; % keytype)
                return False
            elif not published:
                output(&quot;ERROR: No %s's are published after this event&quot;
                        % keytype)
                return False
            elif not published.intersection(active):
                output(&quot;ERROR: No %s's are both active and published &quot;
                       &quot;after this event&quot; % keytype)
                return False

        return True

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython3.6%2Fsite-packages%2Fisc'>Back to Directory</a>