python/samba/uptodateness.py

   1 # Uptodateness utils
   2 #
   3 # Copyright (C) Andrew Bartlett 2015, 2018
   4 # Copyright (C) Douglas Bagnall <douglas.bagnall@catalyst.net.nz>
   5 # Copyright (C) Joe Guo <joeg@catalyst.net.nz>
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 from __future__ import print_function
  20
  21 import sys
  22 import time
  23
  24 from ldb import SCOPE_BASE, LdbError
  25
  26 from samba import nttime2unix, dsdb
  27 from samba.netcmd import CommandError
  28 from samba.samdb import SamDB
  29 from samba.kcc import KCC
  30
  31
  32 def get_kcc_and_dsas(url, lp, creds):
  33     """Get a readonly KCC object and the list of DSAs it knows about."""
  34     unix_now = int(time.time())
  35     kcc = KCC(unix_now, readonly=True)
  36     kcc.load_samdb(url, lp, creds)
  37
  38     dsa_list = kcc.list_dsas()
  39     dsas = set(dsa_list)
  40     if len(dsas) != len(dsa_list):
  41         print("There seem to be duplicate dsas", file=sys.stderr)
  42
  43     return kcc, dsas
  44
  45
  46 def get_partition_maps(samdb):
  47     """Generate dictionaries mapping short partition names to the
  48     appropriate DNs."""
  49     base_dn = samdb.domain_dn()
  50     short_to_long = {
  51         "DOMAIN": base_dn,
  52         "CONFIGURATION": str(samdb.get_config_basedn()),
  53         "SCHEMA": "CN=Schema,%s" % samdb.get_config_basedn(),
  54         "DNSDOMAIN": "DC=DomainDnsZones,%s" % base_dn,
  55         "DNSFOREST": "DC=ForestDnsZones,%s" % base_dn
  56     }
  57
  58     long_to_short = {}
  59     for s, l in short_to_long.items():
  60         long_to_short[l] = s
  61
  62     return short_to_long, long_to_short
  63
  64
  65 def get_partition(samdb, part):
  66     # Allow people to say "--partition=DOMAIN" rather than
  67     # "--partition=DC=blah,DC=..."
  68     if part is not None:
  69         short_partitions, long_partitions = get_partition_maps(samdb)
  70         part = short_partitions.get(part.upper(), part)
  71         if part not in long_partitions:
  72             raise CommandError("unknown partition %s" % part)
  73     return part
  74
  75
  76 def get_utdv(samdb, dn):
  77     """This finds the uptodateness vector in the database."""
  78     cursors = []
  79     config_dn = samdb.get_config_basedn()
  80     for c in dsdb._dsdb_load_udv_v2(samdb, dn):
  81         inv_id = str(c.source_dsa_invocation_id)
  82         res = samdb.search(base=config_dn,
  83                            expression=("(&(invocationId=%s)"
  84                                        "(objectClass=nTDSDSA))" % inv_id),
  85                            attrs=["distinguishedName", "invocationId"])
  86         settings_dn = str(res[0]["distinguishedName"][0])
  87         prefix, dsa_dn = settings_dn.split(',', 1)
  88         if prefix != 'CN=NTDS Settings':
  89             raise CommandError("Expected NTDS Settings DN, got %s" %
  90                                settings_dn)
  91
  92         cursors.append((dsa_dn,
  93                         inv_id,
  94                         int(c.highest_usn),
  95                         nttime2unix(c.last_sync_success)))
  96     return cursors
  97
  98
  99 def get_own_cursor(samdb):
 100     res = samdb.search(base="",
 101                        scope=SCOPE_BASE,
 102                        attrs=["highestCommittedUSN"])
 103     usn = int(res[0]["highestCommittedUSN"][0])
 104     now = int(time.time())
 105     return (usn, now)
 106
 107
 108 def get_utdv_edges(local_kcc, dsas, part_dn, lp, creds):
 109     # we talk to each remote and make a matrix of the vectors
 110     # for each partition
 111     # normalise by oldest
 112     utdv_edges = {}
 113     for dsa_dn in dsas:
 114         res = local_kcc.samdb.search(dsa_dn,
 115                                      scope=SCOPE_BASE,
 116                                      attrs=["dNSHostName"])
 117         ldap_url = "ldap://%s" % res[0]["dNSHostName"][0]
 118         try:
 119             samdb = SamDB(url=ldap_url, credentials=creds, lp=lp)
 120             cursors = get_utdv(samdb, part_dn)
 121             own_usn, own_time = get_own_cursor(samdb)
 122             remotes = {dsa_dn: own_usn}
 123             for dn, guid, usn, t in cursors:
 124                 remotes[dn] = usn
 125         except LdbError as e:
 126             print("Could not contact %s (%s)" % (ldap_url, e),
 127                   file=sys.stderr)
 128             continue
 129         utdv_edges[dsa_dn] = remotes
 130     return utdv_edges
 131
 132
 133 def get_utdv_distances(utdv_edges, dsas):
 134     distances = {}
 135     for dn1 in dsas:
 136         try:
 137             peak = utdv_edges[dn1][dn1]
 138         except KeyError as e:
 139             peak = 0
 140         d = {}
 141         distances[dn1] = d
 142         for dn2 in dsas:
 143             if dn2 in utdv_edges:
 144                 if dn1 in utdv_edges[dn2]:
 145                     dist = peak - utdv_edges[dn2][dn1]
 146                     d[dn2] = dist
 147                 else:
 148                     print("Missing dn %s from UTD vector" % dn1,
 149                           file=sys.stderr)
 150             else:
 151                 print("missing dn %s from UTD vector list" % dn2,
 152                       file=sys.stderr)
 153     return distances
 154
 155
 156 def get_utdv_max_distance(distances):
 157     max_distance = 0
 158     for vector in distances.values():
 159         for distance in vector.values():
 160             max_distance = max(max_distance, distance)
 161     return max_distance
 162
 163
 164 def get_utdv_summary(distances, filters=None):
 165     maximum = failure = 0
 166     median = 0.0  # could be average of 2 median values
 167     values = []
 168     # put all values into a list, exclude self to self ones
 169     for dn_outer, vector in distances.items():
 170         for dn_inner, distance in vector.items():
 171             if dn_outer != dn_inner:
 172                 values.append(distance)
 173
 174     if values:
 175         values.sort()
 176         maximum = values[-1]
 177         length = len(values)
 178         if length % 2 == 0:
 179             index = length/2 - 1
 180             median = (values[index] + values[index+1])/2.0
 181             median = round(median, 1)  # keep only 1 decimal digit like 2.5
 182         else:
 183             index = (length - 1)/2
 184             median = values[index]
 185             median = float(median)  # ensure median is always a float like 1.0
 186         # if value not exist, that's a failure
 187         expected_length = len(distances) * (len(distances) - 1)
 188         failure = expected_length - length
 189
 190     summary = {
 191         'maximum': maximum,
 192         'median': median,
 193         'failure': failure,
 194     }
 195
 196     if filters:
 197         return {key: summary[key] for key in filters}
 198     else:
 199         return summary