def _sorted_ldif_entry(entry_dn, entry_data):
"""Generate a *sorted* version 1 LDIF entry.
The goal is that each entry's attribute is in alphabetical ordered.
Needed to have "stable" dumps, to be able to put them in version control.
:returns:
``str`` - LDIFv1 representation of the entry.
"""
# Make a sorted dictionary of key to list of utf8 encoded values
prepared_data = collections.OrderedDict(
[
(
key,
[
datum.decode()
for datum in entry_data[key]
]
)
for key in sorted(entry_data.keys())
]
)
output_stream = io.BytesIO()
writer = ldif3.LDIFWriter(output_stream, cols=78)
writer.unparse(
entry_dn, prepared_data
)
return output_stream.getvalue().decode()
def get(self, request, *args, **kwargs):
context_data = self.get_context_data(**kwargs)
try:
import ldif3
except ImportError:
s = 'No ldif3 module\n'
return HttpResponse(s, content_type='text/plain; charset=utf8')
buf = io.BytesIO()
ldif_writer = ldif3.LDIFWriter(buf)
person_list = context_data['person_list']
for person in person_list:
dn = 'cn=%s' % person['name']
entry = {
'cn': [person['name']],
'mail': [person['email']],
'phone': [person['phone']],
}
ldif_writer.unparse(dn, entry)
return HttpResponse(buf.getvalue(),
content_type='text/plain; charset=utf8')
def save_result(output, result):
ldif_writer = ldif3.LDIFWriter(output)
for dn, entry in result:
if dn is not None:
ldif_writer.unparse(dn, entry)
def setUp(self):
self.stream = BytesIO()
self.w = ldif3.LDIFWriter(self.stream)
# populate from
fromparser = ldif3.LDIFParser(open(sys.argv[1], mode="rb"))
fromparser.parse()
from_dict = {k: v for k, v in fromparser.parse()}
from_set = set(from_dict)
logging.info("from: %d entries" % len(from_dict))
# populate to
toparser = ldif3.LDIFParser(open(sys.argv[2], mode="rb"))
toparser.parse()
to_dict = {k: v for k, v in toparser.parse()}
to_set = set(to_dict)
logging.info("to: %d entries" % len(to_dict))
writer = ldif3.LDIFWriter(os.fdopen(sys.stdout.fileno(), mode="wb"))
# delete dn's that are only on the to -
todelete = from_set - to_set #
logging.info('Only on to: delete {:d} entries'.format(len(todelete)))
for dn in sorted(todelete, key=dn_parts_count, reverse=True):
writer.unparse(dn, {"changetype": [u"delete"]})
# add records which are only in our from - DNs with less parts first
toadd = to_set - from_set
logging.info("Only on from: add {:d} entries".format(len(toadd)))
for dn in sorted(toadd, key=dn_parts_count):
writer.unparse(dn, [(k, v) for k, v in to_dict[dn].items()])
# create modify items where dn is same but attrs differ
modifys = {} # Dict[dn, -> entry]
