Why:
  The main metrics one wishes to obtain from a dhcp server of a particular
  type (Kea DHCP, ISC DHCP, udhcpd, etc.) are the same accross the
  board, and thus the methods that process these metrics (e.g. sending
  them to a graphite server, creating a canonical graphite path for a
  specific type of metric, etc) are better off being defined once in a
  superclass.

…Source clearer

KeaDhcpMetricSource is an implementation of DhcpMetricSource which
collects the four metrics defined in the DhcpMetricKeys enum (number
of total, used, free and touched addresses) for each vlan of a Kea
DHCP server.

Why:
  I'll need to check more carefully how to obtain the amount of free
  addresses in a subnet, it proboably must be calculated since Kea
  doesn't seem to supply it.

Need to see how to deal with shared networks that might also be
defined as well. Should be exactly the same as for subnets, since a
shared network really is just a uniquely named list of subnets.

why:
    This is build-up for an up-coming commit that implements caching
    of self.kea_dhcp_config in KeaDhcpMetricSource; everytime we fetch
    a new kea_dhcp_config with fetch_dhcp_config(), we would like to
    store it as well - hence the name change of the function.

    The up-coming commit will then make use of Kea Control Agent's
    `config-hash-get` command (included in Kea versions >= 2.4.0) to
    check if we need to update the cached config or not whenever
    set_and_fetch_dhcp_config() is called.

…new config

What:
    In addition to updating function names etc., I've also updated the
    mocking of the requests.post requests in the test script so that
    we can give different respsonses based on the Kea Control Agent
    command the kea_dhcp_data script sends to the Kea Control Agent
    server with its request.post calls

For now, I'll just call this new function for unwrap(), since all of
the uses of send_query() expects a list of one response and the first
thing that is done is always to unwrap the singleton response
list. unwrap() could be made to have generic typing, but for
simplicity it uses KeaResponse instead of a generic TypeVar('T') for
now.

Also fixes a typo on line 342 where an extra comma had sneaked
itself into the code

What:
    Before, we only included subnets defined in the subnet[4,6]
    section of the Kea DHCP config obtained through the "config-get"
    query in the KeaDhcpConfig.subnets list. Now we also include the
    subnets defined in the shared-networks section of the Kea DHCP
    config, and thus we include all subnets than could possibly be
    configured for a Kea DHCP server, which means that we can now
    fetch metrics from all defined subnets.

…urce

what:
    prior to this commit, the key for a specific metric (i.e. the name
    of that metric used by NAV) had the same naming convention as
    dhcpd-pools(1), e.g. "cur" was the name used for the "amount of
    addresses currently assigned to dhcp clients on this subnet" and
    "max" was the name used for the "total amount of addresses
    controlled by this subnet". DhcpMetricKey.CUR and
    DhcpMetricKey.MAX, however, is not very descriptive, so I changed
    the key names to be DhcpMetricKey.TOTAL and
    DhcpMetricKey.ASSIGNED. DhcpMetricKey.TOUCH was removed all
    together because it seems to me like this is not a common metric
    to be reported by dhcp servers (dhcpd-pools(1) uses "touch" to
    mean the number of assigned addresses that has timed out but that
    is not yet marked as re-assignable by the dhcp-server).

what:
    Modify the docstrings so that they all follow the same pattern;
    i.e. they all begin by describing what they return.

why:
    In the future, one might want to include sensitive information,
    such as passwords or tokens in requests, and a response from Kea
    might contain secrets, especially with regards to "config-get"
    responses, where a config might contain passwords.

what:
    before this change, our mocking functionality only allowed for
    setting the string of the response object that is returned by
    requests.post() and requests.Session().post(), by using

    responsequeue.add("<command-name>", "<returned-string>").
    responsequeue.autofill("dhcp<4 or 6>", config_to_return, statistics_to_return)

    This commit modifies adds an extra parameter to both of these
    functions, the `attrs` parameter:

    responsequeue.add("<command-name>", "<returned-string>", attrs={}).
    responsequeue.autofill("dhcp<4 or 6>", config_to_return, statistics_to_return, attrs={})

    if `attrs` = {"myattr": "myval"}, then the requests.Response()
    object returned by any call to requests.post() or
    requests.Session().post() will have the attribute "myattr":

    attrs = {"myattr", "myval"}
    responsequeue.add("<command-name>", "<returned-string>", attrs)
    response = requests.post(...)
    assert response.myattr == "myval"

(this is what the graphite exporting function expects)