#!/usr/bin/python
|
|
# CDDL HEADER START
|
#
|
# The contents of this file are subject to the terms of the
|
# Common Development and Distribution License, Version 1.0 only
|
# (the "License"). You may not use this file except in compliance
|
# with the License.
|
#
|
# You can obtain a copy of the license at
|
# trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
# or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
# See the License for the specific language governing permissions
|
# and limitations under the License.
|
#
|
# When distributing Covered Code, include this CDDL HEADER in each
|
# file and include the License file at
|
# trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
# add the following below this CDDL HEADER, with the fields enclosed
|
# information:
|
# Portions Copyright [yyyy] [name of copyright owner]
|
#
|
# CDDL HEADER END
|
#
|
#
|
# Copyright 2009 Sun Microsystems, Inc.
|
|
|
|
|
|
# Global variable containing the list of servers ("Server" class instances) deployed
|
|
|
|
# Define ChangelogServer class
|
class OIDDict:
|
"""OIDDict is a dictionary class that help lookup OID <-> litteral name
|
of both objeclasses, and attributtypes"""
|
|
def __init__(self, schema=None):
|
self.attrDict = {}
|
self.objDict = {}
|
self.sup = {}
|
self.may = {}
|
self.must = {}
|
self.allmay = []
|
self.allmust = []
|
|
def _getOID(self, line):
|
"""given a schema entry definition for objectclass/attributtype
|
return the tuple (OID,List of names)
|
the List of aliases starts from list of names[1:] when exist. for ex :
|
attributeTypes: ( 2.5.4.4 NAME ( 'sn' 'surname' ) SUP name X-ORIGIN 'RFC 4519' )
|
(2.5.4.4,['sn','surname']
|
More details : https://www.opends.org/wiki/page/AttributeTypeDescriptionFormat
|
"""
|
pNdx = line.find('(')
|
nNdx = line.find('NAME',pNdx)
|
OID = line[pNdx+1:nNdx].strip()
|
|
# populate the NAME to OID : "dict" dictionary
|
NAMES = self._getStr(line,'NAME')
|
if NAMES:
|
if line.startswith('objectClasses:'):
|
# TODO encoded schema is not handled for now
|
self.objDict.update({OID:NAMES})
|
for name in NAMES:
|
self.objDict.update({name:OID})
|
elif line.startswith('attributeTypes:'):
|
# TODO encoded schema is not handled for now
|
self.attrDict.update({OID:NAMES})
|
for name in NAMES:
|
self.attrDict.update({name:OID})
|
# populate SUP and MUST / MAY, : "sup", "may", "must" dictionaries
|
if line.startswith('objectClasses:'):
|
r = self._getStr(line,'SUP')
|
if r:
|
self.sup.update({NAMES[0]:r})
|
r = self._getStr(line,'MUST')
|
if r:
|
self.must.update({NAMES[0]:r})
|
for m in r:
|
if not m in self.allmust:
|
self.allmust.append(m)
|
r = self._getStr(line,'MAY')
|
if r:
|
self.may.update({NAMES[0]:r})
|
for m in r:
|
if not m in self.allmay:
|
self.allmay.append(m)
|
|
return OID, NAMES
|
|
def _getStr(self, line, myStr, right=None):
|
"""extract a list of attributes for a given myStr section.
|
The section should contain () when multivalued.
|
If another section comes after it starts with a Upercase.
|
example MUST (sn cn) MAY ( description ... )
|
|
line : line to parse
|
myStr : name of the section ex(MAY)
|
right : right boundary,
|
if None, function will figure out end of section"""
|
left = line.find(myStr)
|
if left == -1:
|
return None
|
|
if not right:
|
right = len(line)
|
lpNdx = line.find('(', left)
|
if lpNdx > 0:
|
spaces=line[left+len(myStr) : lpNdx]
|
if len(spaces.strip()) == 0:
|
right = line.find(')',lpNdx)
|
left = lpNdx + 1
|
else:
|
left = left+len(myStr)+1
|
else:
|
left = left+len(myStr)
|
strs = line[left:right]
|
realStrs = []
|
for s in strs.split(' '):
|
if len(s) > 0:
|
if s[0] >= 'A' and s[0] <= 'Z':
|
break
|
elif s[0] != '$' and s[0] != '|':
|
if s[0] == '\'' and s[-1] == '\'':
|
s = s[1:-1]
|
realStrs.append(s.lower())
|
return realStrs
|
|
def getMust(self, objectclassname):
|
"""will return the attributes the objectclassname MUST implement"""
|
if self.must.has_key(objectclassname):
|
ret = self.must.get(objectclassname)
|
else:
|
ret = []
|
for h in self.getHierarchy(objectclassname):
|
# avoiding duplication of MUSTs
|
ret.extend([e for e in self.getMust(h) if ret.count(e) == 0])
|
return ret
|
|
def getMay(self, objectclassname):
|
"""will return the attributes the objectclassname MAY implement"""
|
if self.may.has_key(objectclassname):
|
ret = self.may.get(objectclassname)
|
else:
|
ret = []
|
for h in self.getHierarchy(objectclassname):
|
# avoiding duplication of MAYs
|
ret.extend([e for e in self.getMay(h) if ret.count(e) == 0])
|
return ret
|
|
def getSup(self, objectclassname):
|
"""will return the objectclassname that this objectclassname inherit"""
|
if objectclassname == 'top':
|
return None
|
else:
|
ret = self.sup.get(objectclassname)
|
return ret[0]
|
|
def getHierarchy(self, objectclassname):
|
hierachy = []
|
up = self.getSup(objectclassname)
|
while up:
|
if hierachy.count(up) == 0:
|
hierachy.append(up)
|
up = self.getSup(up)
|
return hierachy
|
|
|
def parseSchema(self, ref_content):
|
"""get the schema as a string
|
lookit up line by line, extracting OID/literal name for objectclasses
|
and attributetypes only."""
|
lines=[]
|
line=''
|
for f in ref_content.splitlines():
|
if len(line) == 0 and \
|
not (f.startswith("objectClasses") or \
|
f.startswith("attributeTypes")):
|
# not handled for now
|
continue
|
elif len(line) > 0 and len(f) > 0 and f[0].isspace():
|
# line continuation aggregated into 'line'
|
line += f[1:]
|
|
elif f.startswith("objectClasses") or f.startswith("attributeTypes"):
|
if len(line) > 0:
|
lines.append(line)
|
# populate the OID <-> Names dictionary
|
self._getOID(line)
|
line = f[:-1]
|
line = f
|
if len(line) > 0:
|
# parsing the last line
|
self._getOID(line)
|
lines.append(line)
|
f=open('/tmp/lines.ldif','w')
|
f.write('\n'.join(lines))
|
f.close()
|
|
if __name__ == '__main__':
|
"""get example schema.ldif file with :
|
ldapsearch -b 'cn=schema' -Dcn=directory\ manager -s base -wpassword objectclass=* objectClasses attributeTypes > /tmp/schema.ldif
|
"""
|
objectClassesFileName='/tmp/schema.ldif'
|
f = open(objectClassesFileName)
|
fc = f.readlines()
|
f.close()
|
oidDict = OIDDict()
|
oidDict.parseSchema(''.join(fc))
|
print '[ Objectclasses dictionary ]'.center(80, '-')
|
for k,v in oidDict.objDict.items():
|
print "%s\t%s"%(k,v)
|
print '[ AttributeTypes dictionary ]'.center(80, '-')
|
for k,v in oidDict.attrDict.items():
|
print "%s\t%s"%(k,v)
|
print '[ must ]'.center(80, '-')
|
for k,v in oidDict.must.items():
|
print "%s\t%s"%(k,v)
|
print '[ may ]'.center(80, '-')
|
for k,v in oidDict.may.items():
|
print "%s\t%s"%(k,v)
|
print '[ sup ]'.center(80, '-')
|
for k,v in oidDict.sup.items():
|
print "%s\t%s"%(k,v)
|
for cn in ['rFC822LocalPart','inetOrgPerson','top','doMain','2.5.6.7','BLAH']:
|
print cn.center(80, '-')
|
try:
|
print 'SUP'.center(40,'.')
|
print 'SUP',oidDict.getSup(cn)
|
print 'HIERARCHY',oidDict.getHierarchy(cn)
|
print 'MUST'.center(40,'.')
|
print 'MUST',oidDict.getMust(cn)
|
print 'MAY'.center(40,'.')
|
print 'MAY',oidDict.getMay(cn)
|
except Exception, e:
|
print e.message
|
print '[ all must ]'.center(80,'-')
|
mustSize = 0
|
for m in oidDict.allmust:
|
mustSize += len(m)
|
print 'got %s MUSTs size = %sKb' % (len(oidDict.allmust),mustSize/1024.0)
|
print oidDict.allmust
|
print '[ all may ]'.center(80,'-')
|
maySize = 0
|
for m in oidDict.allmay:
|
maySize += len(m)
|
print 'got %s MAYs size = %sKb' % (len(oidDict.allmay),maySize/1024.0)
|
print oidDict.allmay
|
