Commit e6d2c664d94fc281b1658379f70b4d1a8b46ac98 - dnsviz

+7

-2

dnsviz/analysis/errors.py less more

21	21	from __future__ import unicode_literals
22	22
23	23	import cgi
24		import collections
25	24	import datetime
	25
	26	# minimal support for python2.6
	27	try:
	28	from collections import OrderedDict
	29	except ImportError:
	30	from ordereddict import OrderedDict
26	31
27	32	import dns.dnssec
28	33

104	109	del self.servers_clients[(server, client)]
105	110
106	111	def serialize(self, consolidate_clients=False, html_format=False):
107		d = collections.OrderedDict()
	112	d = OrderedDict()
108	113
109	114	if html_format:
110	115	d['description'] = self.html_description

+19

-14

dnsviz/analysis/offline.py less more

26	26
27	27	from __future__ import unicode_literals
28	28
29		import collections
30	29	import errno
31	30	import logging
	31
	32	# minimal support for python2.6
	33	try:
	34	from collections import OrderedDict
	35	except ImportError:
	36	from ordereddict import OrderedDict
32	37
33	38	import dns.flags, dns.rdataclass, dns.rdatatype
34	39

462	467
463	468	def _serialize_status_simple(self, response_info_list, processed):
464	469	tup = []
465		cname_info_map = collections.OrderedDict()
	470	cname_info_map = OrderedDict()
466	471
467	472	# just get the first one since the names are all supposed to be the
468	473	# same

2279	2284	self.response_component_status = response_component_status
2280	2285
2281	2286	def _serialize_rrset_info(self, rrset_info, consolidate_clients=False, show_servers=True, loglevel=logging.DEBUG, html_format=False):
2282		d = collections.OrderedDict()
	2287	d = OrderedDict()
2283	2288
2284	2289	rrsig_list = []
2285	2290	if self.rrsig_status[rrset_info]:

2301	2306	if dname_serialized:
2302	2307	dname_list.append(dname_serialized)
2303	2308
2304		wildcard_proof_list = collections.OrderedDict()
	2309	wildcard_proof_list = OrderedDict()
2305	2310	if rrset_info.wildcard_info:
2306	2311	wildcard_names = list(rrset_info.wildcard_info.keys())
2307	2312	wildcard_names.sort()

2365	2370	return d
2366	2371
2367	2372	def _serialize_negative_response_info(self, neg_response_info, neg_status, warnings, errors, consolidate_clients=False, loglevel=logging.DEBUG, html_format=False):
2368		d = collections.OrderedDict()
	2373	d = OrderedDict()
2369	2374
2370	2375	proof_list = []
2371	2376	for nsec_status in neg_status[neg_response_info]:

2419	2424	return d
2420	2425
2421	2426	def _serialize_query_status(self, query, consolidate_clients=False, loglevel=logging.DEBUG, html_format=False):
2422		d = collections.OrderedDict()
	2427	d = OrderedDict()
2423	2428	d['answer'] = []
2424	2429	d['nxdomain'] = []
2425	2430	d['nodata'] = []

2482	2487	return d
2483	2488
2484	2489	def _serialize_delegation_status(self, rdtype, consolidate_clients=False, loglevel=logging.DEBUG, html_format=False):
2485		d = collections.OrderedDict()
	2490	d = OrderedDict()
2486	2491
2487	2492	dss = list(self.ds_status_by_ds[rdtype].keys())
2488	2493	d['ds'] = []

2531	2536	return d
2532	2537
2533	2538	def _serialize_zone_status(self, consolidate_clients=False, loglevel=logging.DEBUG, html_format=False):
2534		d = collections.OrderedDict()
	2539	d = OrderedDict()
2535	2540
2536	2541	if loglevel <= logging.DEBUG:
2537	2542	glue_ip_mapping = self.get_glue_ip_mapping()
2538	2543	auth_ns_ip_mapping = self.get_auth_ns_ip_mapping()
2539		d['servers'] = collections.OrderedDict()
	2544	d['servers'] = OrderedDict()
2540	2545	names = list(self.get_ns_names())
2541	2546	names.sort()
2542	2547	for name in names:
2543	2548	name_str = lb2s(name.canonicalize().to_text())
2544		d['servers'][name_str] = collections.OrderedDict()
	2549	d['servers'][name_str] = OrderedDict()
2545	2550	if name in glue_ip_mapping and glue_ip_mapping[name]:
2546	2551	servers = list(glue_ip_mapping[name])
2547	2552	servers.sort()

2569	2574	name_str = lb2s(name.canonicalize().to_text())
2570	2575	servers = stealth_mapping[name]
2571	2576	servers.sort()
2572		d['servers'][name_str] = collections.OrderedDict((
	2577	d['servers'][name_str] = OrderedDict((
2573	2578	('stealth', servers),
2574	2579	))
2575	2580

2586	2591
2587	2592	def serialize_status(self, d=None, is_dlv=False, loglevel=logging.DEBUG, ancestry_only=False, level=RDTYPES_ALL, trace=None, follow_mx=True, html_format=False):
2588	2593	if d is None:
2589		d = collections.OrderedDict()
	2594	d = OrderedDict()
2590	2595
2591	2596	if trace is None:
2592	2597	trace = []

2649	2654
2650	2655	erroneous_status = self.status not in (Status.NAME_STATUS_NOERROR, Status.NAME_STATUS_NXDOMAIN)
2651	2656
2652		d[name_str] = collections.OrderedDict()
	2657	d[name_str] = OrderedDict()
2653	2658	if loglevel <= logging.INFO or erroneous_status:
2654	2659	d[name_str]['status'] = Status.name_status_mapping[self.status]
2655	2660
2656		d[name_str]['queries'] = collections.OrderedDict()
	2661	d[name_str]['queries'] = OrderedDict()
2657	2662	query_keys = list(self.queries.keys())
2658	2663	query_keys.sort()
2659	2664	required_rdtypes = self._rdtypes_for_analysis_level(level)

+11

-6

dnsviz/analysis/online.py less more

26	26
27	27	from __future__ import unicode_literals
28	28
29		import collections
30	29	import datetime
31	30	import logging
32	31	import random

36	35	import threading
37	36	import time
38	37	import uuid
	38
	39	# minimal support for python2.6
	40	try:
	41	from collections import OrderedDict
	42	except ImportError:
	43	from ordereddict import OrderedDict
39	44
40	45	import dns.flags, dns.name, dns.rdataclass, dns.rdatatype, dns.resolver
41	46

710	715
711	716	def serialize(self, d=None, meta_only=False, trace=None):
712	717	if d is None:
713		d = collections.OrderedDict()
	718	d = OrderedDict()
714	719
715	720	if trace is None:
716	721	trace = []

738	743	clients_ipv6 = list(self.clients_ipv6)
739	744	clients_ipv6.sort()
740	745
741		d[name_str] = collections.OrderedDict()
	746	d[name_str] = OrderedDict()
742	747	d[name_str]['type'] = analysis_types[self.analysis_type]
743	748	d[name_str]['stub'] = self.stub
744	749	d[name_str]['analysis_start'] = fmt.datetime_to_str(self.analysis_start)

767	772
768	773	def _serialize_related(self, d, meta_only):
769	774	if self._auth_ns_ip_mapping:
770		d['auth_ns_ip_mapping'] = collections.OrderedDict()
	775	d['auth_ns_ip_mapping'] = OrderedDict()
771	776	ns_names = list(self._auth_ns_ip_mapping.keys())
772	777	ns_names.sort()
773	778	for name in ns_names:

1219	1224	rdtypes.extend([dns.rdatatype.A, dns.rdatatype.AAAA])
1220	1225
1221	1226	# remove duplicates
1222		rdtypes = list(collections.OrderedDict.fromkeys(rdtypes))
	1227	rdtypes = list(OrderedDict.fromkeys(rdtypes))
1223	1228
1224	1229	return rdtypes
1225	1230

1745	1750	if not parent_auth_servers:
1746	1751	return False
1747	1752
1748		servers_queried = collections.OrderedDict(((dns.rdatatype.NS, set()),))
	1753	servers_queried = OrderedDict(((dns.rdatatype.NS, set()),))
1749	1754	referral_queries = {}
1750	1755
1751	1756	try:

+19

-14

dnsviz/analysis/status.py less more

28	28
29	29	import base64
30	30	import cgi
31		import collections
32	31	import datetime
33	32	import logging
	33
	34	# minimal support for python2.6
	35	try:
	36	from collections import OrderedDict
	37	except ImportError:
	38	from ordereddict import OrderedDict
34	39
35	40	import dns.name, dns.rdatatype
36	41

227	232	return 'RRSIG covering %s/%s' % (fmt.humanize_name(self.rrset.rrset.name), dns.rdatatype.to_text(self.rrset.rrset.rdtype))
228	233
229	234	def serialize(self, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
230		d = collections.OrderedDict()
	235	d = OrderedDict()
231	236
232	237	erroneous_status = self.validation_status not in (RRSIG_STATUS_VALID, RRSIG_STATUS_INDETERMINATE_NO_DNSKEY, RRSIG_STATUS_INDETERMINATE_UNKNOWN_ALGORITHM)
233	238

366	371	return '%s record(s) corresponding to DNSKEY for %s (algorithm %d (%s), key tag %d)' % (dns.rdatatype.to_text(self.ds_meta.rrset.rdtype), fmt.humanize_name(self.ds_meta.rrset.name), self.ds.algorithm, fmt.DNSKEY_ALGORITHMS.get(self.ds.algorithm, self.ds.algorithm), self.ds.key_tag)
367	372
368	373	def serialize(self, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
369		d = collections.OrderedDict()
	374	d = OrderedDict()
370	375
371	376	erroneous_status = self.validation_status not in (DS_STATUS_VALID, DS_STATUS_INDETERMINATE_NO_DNSKEY, DS_STATUS_INDETERMINATE_UNKNOWN_ALGORITHM)
372	377

510	515	return 'NSEC record(s) proving the non-existence (NXDOMAIN) of %s' % (fmt.humanize_name(self.qname))
511	516
512	517	def serialize(self, rrset_info_serializer=None, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
513		d = collections.OrderedDict()
	518	d = OrderedDict()
514	519
515	520	nsec_list = []
516	521	for nsec_rrset in self.nsec_set_info.rrsets.values():

547	552	qname, nsec_names = list(self.nsec_names_covering_qname.items())[0]
548	553	nsec_name = list(nsec_names)[0]
549	554	nsec_rr = self.nsec_set_info.rrsets[nsec_name].rrset[0]
550		d['sname_covering'] = collections.OrderedDict((
	555	d['sname_covering'] = OrderedDict((
551	556	('covered_name', formatter(lb2s(qname.canonicalize().to_text()))),
552	557	('nsec_owner', formatter(lb2s(nsec_name.canonicalize().to_text()))),
553	558	('nsec_next', formatter(lb2s(nsec_rr.next.canonicalize().to_text())))

556	561	wildcard, nsec_names = list(self.nsec_names_covering_wildcard.items())[0]
557	562	nsec_name = list(nsec_names)[0]
558	563	nsec_rr = self.nsec_set_info.rrsets[nsec_name].rrset[0]
559		d['wildcard_covering'] = collections.OrderedDict((
	564	d['wildcard_covering'] = OrderedDict((
560	565	('covered_name', formatter(lb2s(wildcard.canonicalize().to_text()))),
561	566	('nsec_owner', formatter(lb2s(nsec_name.canonicalize().to_text()))),
562	567	('nsec_next', formatter(lb2s(nsec_rr.next.canonicalize().to_text())))

761	766	self.nsec_set_info = nsec_set_info.project(*list(nsec_set_info.rrsets))
762	767
763	768	def serialize(self, rrset_info_serializer=None, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
764		d = collections.OrderedDict()
	769	d = OrderedDict()
765	770
766	771	nsec_list = []
767	772	for nsec_rrset in self.nsec_set_info.rrsets.values():

801	806	qname, nsec_names = list(self.nsec_names_covering_qname.items())[0]
802	807	nsec_name = list(nsec_names)[0]
803	808	nsec_rr = self.nsec_set_info.rrsets[nsec_name].rrset[0]
804		d['sname_covering'] = collections.OrderedDict((
	809	d['sname_covering'] = OrderedDict((
805	810	('covered_name', formatter(lb2s(qname.canonicalize().to_text()))),
806	811	('nsec_owner', formatter(lb2s(nsec_name.canonicalize().to_text()))),
807	812	('nsec_next', formatter(lb2s(nsec_rr.next.canonicalize().to_text())))

974	979	self.errors.append(Errors.InvalidNSEC3Hash(name=fmt.format_nsec3_name(name), nsec3_hash=lb2s(base32.b32encode(self.nsec_set_info.rrsets[name].rrset[0].next))))
975	980
976	981	def serialize(self, rrset_info_serializer=None, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
977		d = collections.OrderedDict()
	982	d = OrderedDict()
978	983
979	984	nsec3_list = []
980	985	for nsec_rrset in self.nsec_set_info.rrsets.values():

1030	1035	qname, nsec_names = list(self.nsec_names_covering_qname.items())[0]
1031	1036	nsec_name = list(nsec_names)[0]
1032	1037	next_name = self.nsec_set_info.name_for_nsec3_next(nsec_name)
1033		d['next_closest_encloser_covering'] = collections.OrderedDict((
	1038	d['next_closest_encloser_covering'] = OrderedDict((
1034	1039	('covered_name', formatter(fmt.format_nsec3_name(qname))),
1035	1040	('nsec_owner', formatter(fmt.format_nsec3_name(nsec_name))),
1036	1041	('nsec_next', formatter(fmt.format_nsec3_name(next_name))),

1047	1052	wildcard, nsec_names = list(self.nsec_names_covering_wildcard.items())[0]
1048	1053	nsec_name = list(nsec_names)[0]
1049	1054	next_name = self.nsec_set_info.name_for_nsec3_next(nsec_name)
1050		d['wildcard_covering'] = collections.OrderedDict((
	1055	d['wildcard_covering'] = OrderedDict((
1051	1056	('covered_name', formatter(fmt.format_nsec3_name(wildcard))),
1052	1057	('nsec3_owner', formatter(fmt.format_nsec3_name(nsec_name))),
1053	1058	('nsec3_next', formatter(fmt.format_nsec3_name(next_name))),

1325	1330	self.errors.append(Errors.InvalidNSEC3Hash(name=fmt.format_nsec3_name(name), nsec3_hash=lb2s(base32.b32encode(self.nsec_set_info.rrsets[name].rrset[0].next))))
1326	1331
1327	1332	def serialize(self, rrset_info_serializer=None, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
1328		d = collections.OrderedDict()
	1333	d = OrderedDict()
1329	1334
1330	1335	nsec3_list = []
1331	1336	for nsec_rrset in self.nsec_set_info.rrsets.values():

1387	1392	qname, nsec_names = list(self.nsec_names_covering_qname.items())[0]
1388	1393	nsec_name = list(nsec_names)[0]
1389	1394	next_name = self.nsec_set_info.name_for_nsec3_next(nsec_name)
1390		d['next_closest_encloser_covering'] = collections.OrderedDict((
	1395	d['next_closest_encloser_covering'] = OrderedDict((
1391	1396	('covered_name', formatter(fmt.format_nsec3_name(qname))),
1392	1397	('nsec3_owner', formatter(fmt.format_nsec3_name(nsec_name))),
1393	1398	('nsec3_next', formatter(fmt.format_nsec3_name(next_name))),

1462	1467
1463	1468	def serialize(self, rrset_info_serializer=None, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
1464	1469	values = []
1465		d = collections.OrderedDict()
	1470	d = OrderedDict()
1466	1471
1467	1472	dname_serialized = None
1468	1473	if rrset_info_serializer is not None:

+7

-2

dnsviz/commands/grok.py less more

22	22	from __future__ import unicode_literals
23	23
24	24	import codecs
25		import collections
26	25	import getopt
27	26	import io
28	27	import json

30	29	import os
31	30	import re
32	31	import sys
	32
	33	# minimal support for python2.6
	34	try:
	35	from collections import OrderedDict
	36	except ImportError:
	37	from ordereddict import OrderedDict
33	38
34	39	import dns.exception, dns.name
35	40

315	320	if not name_objs:
316	321	sys.exit(4)
317	322
318		d = collections.OrderedDict()
	323	d = OrderedDict()
319	324	for name_obj in name_objs:
320	325	name_obj.populate_status(trusted_keys)
321	326

+8

-3

dnsviz/commands/probe.py less more

22	22	from __future__ import unicode_literals
23	23
24	24	import atexit
25		import collections
26	25	import codecs
27	26	import errno
28	27	import getopt

43	42	import tempfile
44	43	import threading
45	44	import time
	45
	46	# minimal support for python2.6
	47	try:
	48	from collections import OrderedDict
	49	except ImportError:
	50	from ordereddict import OrderedDict
46	51
47	52	# python3/python2 dual compatibility
48	53	try:

1054	1059	sys.exit(3)
1055	1060
1056	1061	def _flush(name_obj):
1057		d = collections.OrderedDict()
	1062	d = OrderedDict()
1058	1063	name_obj.serialize(d)
1059	1064	s = json.dumps(d, **kwargs)
1060	1065	lindex = s.index('{')

1098	1103	if not name_objs:
1099	1104	sys.exit(4)
1100	1105
1101		d = collections.OrderedDict()
	1106	d = OrderedDict()
1102	1107	for name_obj in name_objs:
1103	1108	name_obj.serialize(d, meta_only)
1104	1109	d['_meta._dnsviz.'] = dnsviz_meta

+11

-6

dnsviz/query.py less more

28	28
29	29	import base64
30	30	import bisect
31		import collections
32	31	import errno
33	32	import io
34	33	import socket
35	34	import struct
36	35	import time
	36
	37	# minimal support for python2.6
	38	try:
	39	from collections import OrderedDict
	40	except ImportError:
	41	from ordereddict import OrderedDict
37	42
38	43	# python3/python2 dual compatibility
39	44	try:

175	180	def serialize(self):
176	181	'''Return a serialized version of the query.'''
177	182
178		d = collections.OrderedDict()
	183	d = OrderedDict()
179	184	d['time_elapsed'] = int(self.response_time * 1000)
180	185	d['cause'] = retry_causes.get(self.cause, 'UNKNOWN')
181	186	if self.cause_arg is not None:

1064	1069	return False
1065	1070
1066	1071	def serialize(self, meta_only=False):
1067		d = collections.OrderedDict((
	1072	d = OrderedDict((
1068	1073	('qname', lb2s(self.qname.to_text())),
1069	1074	('qclass', dns.rdataclass.to_text(self.rdclass)),
1070	1075	('qtype', dns.rdatatype.to_text(self.rdtype)),
1071	1076	))
1072		d['options'] = collections.OrderedDict((
	1077	d['options'] = OrderedDict((
1073	1078	('flags', self.flags),
1074	1079	))
1075	1080	if self.edns >= 0:

1083	1088	d['options']['edns_options'].append((o.otype, lb2s(base64.b64encode(s.getvalue()))))
1084	1089	d['options']['tcp'] = self.tcp
1085	1090
1086		d['responses'] = collections.OrderedDict()
	1091	d['responses'] = OrderedDict()
1087	1092	servers = list(self.responses.keys())
1088	1093	servers.sort()
1089	1094	for server in servers:
1090		d['responses'][server] = collections.OrderedDict()
	1095	d['responses'][server] = OrderedDict()
1091	1096	clients = list(self.responses[server].keys())
1092	1097	clients.sort()
1093	1098	for client in clients:

+15

-10

dnsviz/response.py less more

30	30	import errno
31	31	import cgi
32	32	import codecs
33		import collections
34	33	import datetime
35	34	import hashlib
36	35	import io

38	37	import socket
39	38	import struct
40	39	import time
	40
	41	# minimal support for python2.6
	42	try:
	43	from collections import OrderedDict
	44	except ImportError:
	45	from ordereddict import OrderedDict
41	46
42	47	import dns.flags, dns.message, dns.rcode, dns.rdataclass, dns.rdatatype, dns.rrset
43	48

453	458	def serialize_meta(self):
454	459	from . import query as Q
455	460
456		d = collections.OrderedDict()
	461	d = OrderedDict()
457	462
458	463	# populate history, if not already populated
459	464	if self.effective_flags is None:

469	474	d['rcode'] = dns.rcode.to_text(self.message.rcode())
470	475	if self.message.edns >= 0:
471	476	d['edns_version'] = self.message.edns
472		d['answer'] = collections.OrderedDict((
	477	d['answer'] = OrderedDict((
473	478	('count', self.section_rr_count(self.message.answer)),
474	479	('digest', self.section_digest(self.message.answer)),
475	480	))
476		d['authority'] = collections.OrderedDict((
	481	d['authority'] = OrderedDict((
477	482	('count', self.section_rr_count(self.message.authority)),
478	483	('digest', self.section_digest(self.message.authority)),
479	484	))
480		d['additional'] = collections.OrderedDict((
	485	d['additional'] = OrderedDict((
481	486	('count', self.section_rr_count(self.message.additional)),
482	487	('digest', self.section_digest(self.message.additional)),
483	488	))

494	499	d['retries'] = self.retries()
495	500	if self.history:
496	501	d['cumulative_response_time'] = int(self.total_response_time() * 1000)
497		d['effective_query_options'] = collections.OrderedDict((
	502	d['effective_query_options'] = OrderedDict((
498	503	('flags', self.effective_flags),
499	504	('edns_version', self.effective_edns),
500	505	('edns_max_udp_payload', self.effective_edns_max_udp_payload),

508	513	d['effective_query_options']['tcp'] = self.effective_tcp
509	514
510	515	if self.responsive_cause_index is not None:
511		d['responsiveness_impediment'] = collections.OrderedDict((
	516	d['responsiveness_impediment'] = OrderedDict((
512	517	('cause', Q.retry_causes[self.history[self.responsive_cause_index].cause]),
513	518	('action', Q.retry_actions[self.history[self.responsive_cause_index].action])
514	519	))

518	523	def serialize(self):
519	524	from . import query as Q
520	525
521		d = collections.OrderedDict()
	526	d = OrderedDict()
522	527	if self.message is None:
523	528	d['message'] = None
524	529	d['error'] = Q.response_errors[self.error]

744	749	(self.warnings and loglevel <= logging.WARNING) or \
745	750	(self.errors and loglevel <= logging.ERROR)
746	751
747		d = collections.OrderedDict()
	752	d = OrderedDict()
748	753
749	754	if html_format:
750	755	formatter = lambda x: cgi.escape(x, True)

924	929	return rrsig_canonicalized_wire + rrset_canonicalized_wire
925	930
926	931	def serialize(self, consolidate_clients=True, show_servers=True, loglevel=logging.DEBUG, html_format=False):
927		d = collections.OrderedDict()
	932	d = OrderedDict()
928	933
929	934	if html_format:
930	935	formatter = lambda x: cgi.escape(x, True)

+8

-3

dnsviz/transport.py less more

23	23	import base64
24	24	import bisect
25	25	import codecs
26		import collections
27	26	import errno
28	27	import fcntl
29	28	import json

36	35	import struct
37	36	import threading
38	37	import time
	38
	39	# minimal support for python2.6
	40	try:
	41	from collections import OrderedDict
	42	except ImportError:
	43	from ordereddict import OrderedDict
39	44
40	45	# python3/python2 dual compatibility
41	46	try:

91	96	self.end_time = None
92	97
93	98	def serialize_request(self):
94		d = collections.OrderedDict()
	99	d = OrderedDict()
95	100	d['req'] = lb2s(base64.b64encode(self.req))
96	101	d['dst'] = self.dst
97	102	d['dport'] = self.dport

162	167	return cls(req, dst, tcp, timeout, dport, src, sport)
163	168
164	169	def serialize_response(self):
165		d = collections.OrderedDict()
	170	d = OrderedDict()
166	171	if self.res is not None:
167	172	d['res'] = lb2s(base64.b64encode(self.res))
168	173	else:

+11

-6

dnsviz/viz/dnssec.py less more

28	28
29	29	import codecs
30	30	import cgi
31		import collections
32	31	import errno
33	32	import io
34	33	import json

36	35	import re
37	36	import sys
38	37	import xml.dom.minidom
	38
	39	# minimal support for python2.6
	40	try:
	41	from collections import OrderedDict
	42	except ImportError:
	43	from ordereddict import OrderedDict
39	44
40	45	import dns.name, dns.rdtypes, dns.rdatatype, dns.dnssec
41	46

75	80	self.key_tag = key_tag
76	81
77	82	def serialize(self):
78		d = collections.OrderedDict()
	83	d = OrderedDict()
79	84	d['flags'] = None
80	85	d['protocol'] = None
81	86	d['algorithm'] = self.algorithm

93	98	self.servers_clients = servers_clients
94	99
95	100	def serialize(self, consolidate_clients, html_format=False):
96		d = collections.OrderedDict()
	101	d = OrderedDict()
97	102
98	103	if html_format:
99	104	formatter = lambda x: cgi.escape(x, True)

575	580	self.node_reverse_mapping[zone_obj] = top_name
576	581
577	582	consolidate_clients = zone_obj.single_client()
578		zone_serialized = collections.OrderedDict()
	583	zone_serialized = OrderedDict()
579	584	zone_serialized['description'] = '%s zone' % (zone_obj)
580	585	if zone_obj.zone_errors:
581	586	zone_serialized['errors'] = [e.serialize(consolidate_clients=consolidate_clients, html_format=True) for e in zone_obj.zone_errors]

811	816
812	817	consolidate_clients = name_obj.single_client()
813	818
814		errors_serialized = collections.OrderedDict()
	819	errors_serialized = OrderedDict()
815	820
816	821	errors_serialized['description'] = '%s %s/%s' % (description, fmt.humanize_name(name), dns.rdatatype.to_text(rdtype))
817	822	errors_serialized[category] = [e.serialize(consolidate_clients=consolidate_clients, html_format=True) for e in errors_list]

1409	1414	line_style = 'dashed'
1410	1415
1411	1416	consolidate_clients = name_obj.single_client()
1412		del_serialized = collections.OrderedDict()
	1417	del_serialized = OrderedDict()
1413	1418	del_serialized['description'] = 'Delegation from %s to %s' % (lb2s(name_obj.parent.name.to_text()), lb2s(name_obj.name.to_text()))
1414	1419	del_serialized['status'] = Status.delegation_status_mapping[name_obj.delegation_status[rdtype]]
1415	1420