def viewUserObjectAJAX(request, group_id, name):
if request.is_ajax():
group = LBEGroup.objects.get(id=group_id)
backend = BackendHelper()
objects = backend.searchObjectsByPattern(group.objectTemplate, name)
list = []
for o in objects:
list.append(o.name)
return HttpResponse(json.dumps(list), mimetype="application/json")
def viewUserObjectAJAX(request, group_id, name):
if request.is_ajax():
group = LBEGroup.objects.get(id=group_id)
backend = BackendHelper()
objects = backend.searchObjectsByPattern(group.objectTemplate, name)
list = []
for o in objects:
list.append(o.name)
return HttpResponse(json.dumps(list), mimetype="application/json")
def searchAJAX(request, lbeObject_id, search):
if len(search) == 0:
return HttpResponse("/")
backend = BackendHelper()
objects = backend.searchObjectsByPattern(LBEObjectTemplate.objects.get(id=lbeObject_id), search)
return render_to_response(
"ajax/directory/search.html",
{"lbeObjectId": lbeObject_id, "objects": objects},
context_instance=RequestContext(request),
)
def _executeOU(self, userID):
# backend db:
backend = BackendHelper()
values = self.word[2].split(',')
for objectName in values:
obj = LBEObjectTemplate.objects.filter(Q(name=objectName) | Q(displayName=objectName))[0]
if backend.getUserUIDForObject(obj, userID):
return True
# No value:
return False
def _executeOU(self, userID):
# backend db:
backend = BackendHelper()
values = self.word[2].split(',')
for objectName in values:
obj = LBEObjectTemplate.objects.filter(
Q(name=objectName) | Q(displayName=objectName))[0]
if backend.getUserUIDForObject(obj, userID):
return True
# No value:
return False
def approvalObjectInstance(request, lbeObject_id, objectName):
backend = BackendHelper()
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
# change status code user:
instanceHelper = LBEObjectInstanceHelper(lbeObject)
instanceHelper.approval(objectName)
# Current page from the object status changed:
position = backend.positionObject(lbeObject.name, objectName)
lengthMax = 10
page = int(math.ceil(position / float(lengthMax)))
return HttpResponseRedirect('/') #return index(request,lbeObject_id,page)
def searchAJAX(request, lbeObject_id, search):
if len(search) == 0:
return HttpResponse('/')
backend = BackendHelper()
objects = backend.searchObjectsByPattern(
LBEObjectTemplate.objects.get(id=lbeObject_id), search)
return render_to_response('ajax/directory/search.html', {
'lbeObjectId': lbeObject_id,
'objects': objects
},
context_instance=RequestContext(request))
def approvalObjectInstance(request, lbeObject_id, objectName):
backend = BackendHelper()
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
# change status code user:
instanceHelper = LBEObjectInstanceHelper(lbeObject)
instanceHelper.approval(objectName)
# Current page from the object status changed:
position = backend.positionObject(lbeObject.name, objectName)
lengthMax = 10
page = int(math.ceil(position / float(lengthMax)))
return HttpResponseRedirect("/") # return index(request,lbeObject_id,page)
def listObjects(request, lbeObject_id=1, page=1):
# init object:
if lbeObject_id is None:
lbeObject_id = 1
if settings.PAGINATION is None:
lengthMax = 25
else:
lengthMax = settings.PAGINATION
# init pagination:
if page is None:
page = 1
else:
page = int(page)
if page == 1:
index = 0
else:
index = int(page) + lengthMax - 2
backend = BackendHelper()
objects = backend.searchObjects(
LBEObjectTemplate.objects.get(id=lbeObject_id), index, lengthMax)
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
lbeObjects = LBEObjectTemplate.objects.all()
# Pagination:
size = int(
math.ceil(
backend.lengthObjects(
LBEObjectTemplate.objects.get(id=lbeObject_id)) /
float(lengthMax)))
if page < 3:
min = 1
else:
min = page - 2
if size - page > 2:
max = page + 2
else:
max = size
tabSize = []
tabSize.append(min)
for i in range(min, max):
tabSize.append(i + 1)
return render_to_response('directory/default/object/listObjects.html', {
'objects': objects,
'lbeObjectId': lbeObject.id,
'objectTemplateName': lbeObject.displayName,
'lbeObjects': lbeObjects,
'length': tabSize,
'page': int(page),
'minCPage': min,
'maxCPage': max,
'maxPage': size
},
context_instance=RequestContext(request))
def listObjects(request, lbeObject_id=1, page=1):
# init object:
if lbeObject_id is None:
lbeObject_id = 1
if settings.PAGINATION is None:
lengthMax = 25
else:
lengthMax = settings.PAGINATION
# init pagination:
if page is None:
page = 1
else:
page = int(page)
if page == 1:
index = 0
else:
index = int(page) + lengthMax - 2
backend = BackendHelper()
objects = backend.searchObjects(LBEObjectTemplate.objects.get(id=lbeObject_id), index, lengthMax)
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
lbeObjects = LBEObjectTemplate.objects.all()
# Pagination:
size = int(math.ceil(backend.lengthObjects(LBEObjectTemplate.objects.get(id=lbeObject_id)) / float(lengthMax)))
if page < 3:
min = 1
else:
min = page - 2
if size - page > 2:
max = page + 2
else:
max = size
tabSize = []
tabSize.append(min)
for i in range(min, max):
tabSize.append(i + 1)
return render_to_response(
"directory/default/object/listObjects.html",
{
"objects": objects,
"lbeObjectId": lbeObject.id,
"objectTemplateName": lbeObject.displayName,
"lbeObjects": lbeObjects,
"length": tabSize,
"page": int(page),
"minCPage": min,
"maxCPage": max,
"maxPage": size,
},
context_instance=RequestContext(request),
)
class Purge():
def __init__(self):
self.backend = BackendHelper()
def start(self, *objects):
for obj in objects[0]:
print ' |-> Purging \033[90m' + obj + '\033[0m Object...'
try:
o = LBEObjectTemplate.objects.get(name=obj)
for objectInstance in self.backend.searchObjects(o):
if objectInstance.status == OBJECT_STATE_DELETED:
print ' ||-> Removing \033[94m' + objectInstance.name + '\033[0m instance object...'
self.backend.deleteObject(o, objectInstance.name)
except BaseException:
print ' |-> \033[91mThe object "' + obj + '" does not exist.\033[0m'
pass
return 0
def handle(self, *args, **options):
try:
backend = BackendHelper()
target = TargetHelper()
except Exception as e:
print >>sys.stderr, e
sys.exit(1)
for lbeObjectTemplate in LBEObjectTemplate.objects.all():
now = datetime.datetime.now(utc)
# the searchNewObjectcs methods search for backend object where createTimestamp > objectTemplate.imported_at
for lbeObject in target.searchNewObjects(lbeObjectTemplate):
#
# TODO: take care about virtual/reference attributes
# Example: an object where uid is computed as 'bbonfils', but backend value is 'asyd'
lbeObject.synced_at = now
backend.createObject(lbeObjectTemplate, lbeObject)
lbeObjectTemplate.imported_at = now
lbeObjectTemplate.save()
def clean(self):
if not self.cleaned_data == {}: # no value
tab = []
backend = BackendHelper()
values = backend.searchObjects(self.template)
list = []
for value in values:
if value.changes['set'] == {}:
list.append(value.attributes[self.template.instanceNameAttribute.name][0])
else:
list.append(value.changes['set'][self.template.instanceNameAttribute.name][0])
for value in self.cleaned_data[self.groupHelper.attributeName].split('\0'):
if not value == "":
if not value in list:
raise forms.ValidationError("'" + value + "' is not into " + self.template.displayName)
tab.append(value)
return tab
return self.cleaned_data
def handle(self, *args, **options):
try:
backend = BackendHelper()
target = TargetHelper()
except Exception as e:
print >> sys.stderr, e
sys.exit(1)
for lbeObjectTemplate in LBEObjectTemplate.objects.all():
now = datetime.datetime.now(utc)
# the searchNewObjectcs methods search for backend object where createTimestamp > objectTemplate.imported_at
for lbeObject in target.searchNewObjects(lbeObjectTemplate):
#
# TODO: take care about virtual/reference attributes
# Example: an object where uid is computed as 'bbonfils', but backend value is 'asyd'
lbeObject.synced_at = now
backend.createObject(lbeObjectTemplate, lbeObject)
lbeObjectTemplate.imported_at = now
lbeObjectTemplate.save()
class ReinitTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
def _remove(self, objectTemplate, objectInstance):
try:
self.target.delete(objectTemplate, objectInstance)
except BaseException:
# do not care if Target object does not exist
pass
def _create(self, objectTemplate, objectInstance):
# replace attributes by changes set if exist
if not objectInstance.changes['set'] == {}:
# replace the _id value if needed:
rdnAttributeName = objectTemplate.instanceNameAttribute.name
if not objectInstance.attributes[rdnAttributeName][
0] == objectInstance.changes['set'][rdnAttributeName][0]:
self.backend.update_id(
objectTemplate, objectInstance,
objectInstance.changes['set'][rdnAttributeName][0])
# Replace changes['set'] to attributes
objectInstance.attributes = objectInstance.changes['set']
self.target.create(objectTemplate, objectInstance)
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def start(self):
for objectTemplate in LBEObjectTemplate.objects.all():
print " |-> Remove & recreate all objects from \033[91m'" + objectTemplate.name + "'\033[0m :"
for objectInstance in self.backend.searchObjects(objectTemplate):
# do not care about deleted (or in progress deleted) object
if not objectInstance.status == OBJECT_CHANGE_DELETE_OBJECT and \
not objectInstance.status == OBJECT_STATE_DELETED:
print " |-> \033[95m'" + objectInstance.displayName + "\033[0m' ..."
self._remove(objectTemplate, objectInstance)
self._create(objectTemplate, objectInstance)
class ReinitTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
def _remove(self, objectTemplate, objectInstance):
try:
self.target.delete(objectTemplate, objectInstance)
except BaseException:
# do not care if Target object does not exist
pass
def _create(self, objectTemplate, objectInstance):
# replace attributes by changes set if exist
if not objectInstance.changes['set'] == {}:
# replace the _id value if needed:
rdnAttributeName = objectTemplate.instanceNameAttribute.name
if not objectInstance.attributes[rdnAttributeName][0] == objectInstance.changes['set'][rdnAttributeName][0]:
self.backend.update_id(objectTemplate, objectInstance,
objectInstance.changes['set'][rdnAttributeName][0])
# Replace changes['set'] to attributes
objectInstance.attributes = objectInstance.changes['set']
self.target.create(objectTemplate, objectInstance)
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def start(self):
for objectTemplate in LBEObjectTemplate.objects.all():
print " |-> Remove & recreate all objects from \033[91m'" + objectTemplate.name + "'\033[0m :"
for objectInstance in self.backend.searchObjects(objectTemplate):
# do not care about deleted (or in progress deleted) object
if not objectInstance.status == OBJECT_CHANGE_DELETE_OBJECT and \
not objectInstance.status == OBJECT_STATE_DELETED:
print " |-> \033[95m'" + objectInstance.displayName + "\033[0m' ..."
self._remove(objectTemplate, objectInstance)
self._create(objectTemplate, objectInstance)
def deleteObjectInstance(request, lbeObject_id, objectName):
backend = BackendHelper()
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
# change status code user:
instanceHelper = LBEObjectInstanceHelper(lbeObject)
# Remove the object from groups if exists:
for group in LBEGroup.objects.all():
groupHelper = GroupInstanceHelper(group)
try:
groupHelper.removeObjectInstance(lbeObject, objectName)
except KeyError:
pass # same values
# Set to Delete for object Instance
instanceHelper.remove(objectName)
# Current page from the object deleted:
position = backend.positionObject(lbeObject.name, objectName)
lengthMax = 10
page = int(math.ceil(position / float(lengthMax)))
return HttpResponseRedirect('/directory/' + lbeObject_id + "/1")
def deleteObjectInstance(request, lbeObject_id, objectName):
backend = BackendHelper()
lbeObject = LBEObjectTemplate.objects.get(id=lbeObject_id)
# change status code user:
instanceHelper = LBEObjectInstanceHelper(lbeObject)
# Remove the object from groups if exists:
for group in LBEGroup.objects.all():
groupHelper = GroupInstanceHelper(group)
try:
groupHelper.removeObjectInstance(lbeObject, objectName)
except KeyError:
pass # same values
# Set to Delete for object Instance
instanceHelper.remove(objectName)
# Current page from the object deleted:
position = backend.positionObject(lbeObject.name, objectName)
lengthMax = 10
page = int(math.ceil(position / float(lengthMax)))
return HttpResponseRedirect("/directory/" + lbeObject_id + "/1")
def __init__(self, lbeObjectTemplate, *args, **kwargs):
super(forms.Form, self).__init__(*args, **kwargs)
for attributeInstance in lbeObjectTemplate.lbeattributeinstance_set.all().order_by('position'):
# Display finals attributes
if attributeInstance.attributeType == ATTRIBUTE_TYPE_FINAL:
# Regex attribute value [for final attribute]
regex = ''
if not attributeInstance.lbeAttribute.regex == '':
regex = ', validators=[RegexValidator(r"' + attributeInstance.lbeAttribute.regex
if not attributeInstance.lbeAttribute.errorMessage == '':
regex += '","' + attributeInstance.lbeAttribute.errorMessage
regex += '","")]'
exec 'self.fields[attributeInstance.lbeAttribute.name] = ' + attributeInstance.widget + '(' + attributeInstance.widgetArgs + regex + ')'
try:
self.fields[attributeInstance.lbeAttribute.name].label = attributeInstance.lbeAttribute.displayName
self.fields[attributeInstance.lbeAttribute.name].required = bool(attributeInstance.mandatory)
except BaseException:
pass
# Manage & Show references attributes
elif attributeInstance.attributeType == ATTRIBUTE_TYPE_REFERENCE:
backend = BackendHelper()
values = backend.searchObjects(attributeInstance.reference.objectTemplate)
objectHelper = LBEObjectInstanceHelper(attributeInstance.reference.objectTemplate)
# Get values into Dict
listes = dict()
for value in values:
# dict[ID] = Attribute value[0] using ID = frontend's UID
key = attributeInstance.reference.objectTemplate.instanceNameAttribute.name + "=" + value.name + "," + objectHelper.callScriptClassMethod(
'base_dn')
listes[key] = str(value.attributes[attributeInstance.reference.objectAttribute.name][0])
# Create the Field (Dict to tuples):
exec 'self.fields[attributeInstance.lbeAttribute.name] = forms.ChoiceField( ' + str(
listes.items()) + ' )'
try:
self.fields[attributeInstance.lbeAttribute.name].label = attributeInstance.lbeAttribute.displayName
self.fields[attributeInstance.lbeAttribute.name].required = bool(attributeInstance.mandatory)
except BaseException:
pass
def index(request):
objects = LBEObjectTemplate.objects.all()
groups = LBEGroup.objects.all()
backend = BackendHelper()
# Objects
statObjects = []
for object in objects:
lbeObjects = backend.searchObjects(object)
ok = 0
approval = 0
needSync = 0
delete = 0
reconciliation = False
for lbeobject in lbeObjects:
if lbeobject.status == 0:
ok += 1
elif lbeobject.status == 1:
needSync += 1
elif lbeobject.status == 2:
approval += 1
elif lbeobject.status == 3:
reconciliation = True
elif lbeobject.status == 4:
delete += 1
statObjects.append(
{
"name": object.displayName,
"total": len(lbeObjects),
"ok": ok,
"approval": approval,
"sync": needSync,
"reconciliation": reconciliation,
"delete": delete,
}
)
# Groups
statGroups = []
try:
for group in groups:
groupHelper = GroupInstanceHelper(group)
groupHelper.get()
if (
groupHelper.attributeName in groupHelper.instance.changes["set"]
and not groupHelper.instance.changes["set"][groupHelper.attributeName] == []
):
total = len(groupHelper.instance.changes["set"][groupHelper.attributeName])
else:
total = len(groupHelper.instance.attributes[groupHelper.attributeName])
status = groupHelper.instance.status
except BaseException as e:
total = 0
status = -1
statGroups.append(
{
"name": group.displayName,
"total": total,
"object": groupHelper.template.objectTemplate.displayName,
"status": status,
}
)
return render_to_response(
"directory/default/index.html",
{"objects": statObjects, "groups": statGroups},
context_instance=RequestContext(request),
)
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
class UpgradeTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _changeClass(self, objectTemplate):
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("scope_search")
except BaseException:
scope = 0
ob = self.backend.searchObjects(objectTemplate)
for objectInstance in ob:
try:
oldClasses = self.target.getInstanceObjectClasses(
objectTemplate, objectInstance, scope)
except ldap.NO_SUCH_OBJECT:
continue
newClasses = objHelper.callScriptClassMethod("object_classes")
if not sorted(oldClasses) == sorted(newClasses):
print " |-> The object classes have changed for '\033[35m" + objectInstance.displayName + "\033[0m'"
try:
self.target.changeClass(objectTemplate, objectInstance,
oldClasses, newClasses)
except ldap.OBJECT_CLASS_VIOLATION as e:
print " *\033[91mError to modify the object class " + str(
newClasses) + ", skip it.\033[0m"
print " *\033[91m" + e[0]['info'] + "\033[0m"
def _changeRDN(self, objectTemplate):
if objectTemplate.needReconciliationRDN:
print " |-> Upgrade the RDN Target server for \033[35m" + objectTemplate.name + "\033[0m..."
# Change the RDN Attribute to the Target Server
ob = self.backend.searchObjects(objectTemplate)
for o in ob:
try:
self.target.changeRDN(
objectTemplate, o,
objectTemplate.instanceNameBeforeAttribute.name,
o.attributes[objectTemplate.
instanceNameBeforeAttribute.name][0])
except BaseException:
# if object does not exists into the Target Server
pass
self.backend.updateStatus(objectTemplate, o.name)
# Update values for changing RDN attribute
objectTemplate.instanceNameBeforeAttribute = None
objectTemplate.needReconciliationRDN = False
objectTemplate.save()
print " |-> Done."
def _createParent(self, lbeObjectTemplate, objService):
base_dn = objService.callScriptClassMethod("base_dn")
objectToCreate = base_dn.replace(settings.LDAP_SERVER['BASE_DN'],
'')[:-1].split(',')
objectToCreate.reverse()
for i in range(0, len(objectToCreate)):
dn = objectToCreate[i] + ','
for j in range(0, i):
dn = dn + objectToCreate[j] + ','
dn = dn + settings.LDAP_SERVER['BASE_DN']
attrs = {}
attrs['objectclass'] = ['top', 'organizationalUnit']
# do not care if the ou already exists
try:
self.target.createParent(dn, modlist.addModlist(attrs))
except BaseException:
pass
def _createObject(self, objectTemplate, objectInstance):
self.target.create(objectTemplate, objectInstance)
# Ok, the object is added, empty changes set, and update object status
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _modifyObject(self, objectTemplate, objectInstance, SCOPE):
rdnAttributeName = objectTemplate.instanceNameAttribute.name
self.target.update(objectTemplate, objectInstance, SCOPE)
if not objectInstance.attributes[rdnAttributeName][
0] == objectInstance.changes['set'][rdnAttributeName][0]:
self.backend.update_id(
objectTemplate, objectInstance,
objectInstance.changes['set'][rdnAttributeName][0])
# Update Backend value:
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _deleteObject(self, objectTemplate, objectInstance):
self.target.delete(objectTemplate, objectInstance)
# Update Backend value:
changes = {}
changes['status'] = OBJECT_STATE_DELETED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _getRDN(self, objectTemplate, listID):
objectHelper = LBEObjectInstanceHelper(objectTemplate)
baseDN = objectHelper.callScriptClassMethod('base_dn')
listObjectID = []
for ID in listID:
dn = objectTemplate.instanceNameAttribute.name + '=' + ID + ',' + baseDN
listObjectID.append(dn)
return listObjectID
def _getID(self, listRDN):
listID = []
for rdn in listRDN:
listID.append(rdn.split('=')[1].split(',')[0])
return listID
def start(self):
print " Upgrade the Target server with the Backend server..."
for objectTemplate in LBEObjectTemplate.objects.all():
# need to check if we need to change (before making reconciliation) the RDN attribute
self._changeRDN(objectTemplate)
# And the objects class
self._changeClass(objectTemplate)
# We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC
for objectInstance in self.backend.searchObjectsToUpdate(
objectTemplate):
# First of all, applies all changes stored in backend [ such Virtual attributes ]
# & create the parent DN if not exist:
obj = LBEObjectInstanceHelper(objectTemplate, objectInstance)
try:
scope = obj.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
self._createParent(objectTemplate, obj)
#obj.compute(objectInstance)
# then, upgrade:
if objectInstance.changes[
'type'] == OBJECT_CHANGE_CREATE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "\033[0m' is \033[34mcreating\033[0m..."
self._createObject(objectTemplate, objectInstance)
# TODO: We should have a target exception rather ldap
except ldap.ALREADY_EXISTS:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m already exists"
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate,
objectInstance, changes)
pass
elif objectInstance.changes[
'type'] == OBJECT_CHANGE_DELETE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "' is \033[33mdeleting\033[0m..."
self._deleteObject(objectTemplate, objectInstance)
except BaseException as e:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m does not exist."
changes = {}
changes['status'] = OBJECT_STATE_DELETED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate,
objectInstance, changes)
pass
elif objectInstance.changes[
'type'] == OBJECT_CHANGE_UPDATE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m is \033[36mupdating\033[0m..."
# Group
for group in LBEGroup.objects.all():
if group.objectTemplate.id == objectTemplate.id:
GroupInstanceHelper(group).updateMember(
obj.getObject(obj.instance.name))
self._modifyObject(objectTemplate, objectInstance,
scope)
except BaseException as e:
print e
print " |-> Object '\033[35m" + objectInstance.displayName + "' does not exist, being \033[34mcreated\033[0m..."
# Create object if not exists:
# Firstly, compute attributes values:
# Then, create it:
try:
self._createObject(objectTemplate, objectInstance)
except Exception as e:
print e
pass
pass
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print ''
print " Upgrade Groups Objects:"
for groupTemplate in LBEGroup.objects.all():
for groupInstance in self.backend.searchObjectsToUpdate(
groupTemplate):
grp = GroupInstanceHelper(groupTemplate, groupInstance)
try:
scope = grp.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
self._createParent(groupTemplate, grp)
if groupInstance.changes[
'type'] == OBJECT_CHANGE_CREATE_OBJECT:
print " |-> Group '\033[35m" + groupInstance.displayName + "\033[0m' is \033[34mcreating\033[0m..."
try:
groupInstance.changes['set'][
grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate,
groupInstance.changes['set'][
grp.attributeName])
self._createObject(groupTemplate, groupInstance)
###############################################
if not groupInstance.changes['set'] == {}:
groupInstance.changes['set'][
grp.attributeName] = self._getID(
groupInstance.changes['set'][
grp.attributeName])
groupInstance.attributes[
'cn'] = groupInstance.changes['set']['cn']
self.backend.updateObject(
groupTemplate, groupInstance, {
'changes': {
'set': {
'cn': [groupInstance.displayName]
},
'type': -1
}
})
###############################################
except ldap.ALREADY_EXISTS:
print " |-> Group '\033[35m" + groupInstance.displayName + "'\033[0m already exists"
elif groupInstance.changes[
'type'] == OBJECT_CHANGE_UPDATE_OBJECT:
try:
print " |-> Group '\033[35m" + groupInstance.displayName + "'\033[0m is \033[36mupdating\033[0m..."
groupInstance.changes['set'][
grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate,
groupInstance.changes['set'][
grp.attributeName])
self._modifyObject(groupTemplate, groupInstance, scope)
###############################################
groupInstance.changes['set'][
grp.attributeName] = self._getID(
groupInstance.changes['set'][
grp.attributeName])
groupInstance.attributes['cn'] = groupInstance.changes[
'set']['cn']
self.backend.updateObject(
groupTemplate, groupInstance, {
'changes': {
'set': {
'cn': [groupInstance.displayName]
},
'type': -1
}
})
###############################################
except BaseException as e:
print e
print " |-> Group '\033[35m" + groupInstance.displayName + "' does not exist, being \033[34mcreated\033[0m..."
groupInstance.changes['set'][
grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate,
groupInstance.changes['set'][
grp.attributeName])
self._createObject(groupTemplate, groupInstance)
###############################################
groupInstance.changes['set'][
grp.attributeName] = self._getID(
groupInstance.changes['set'][
grp.attributeName])
groupInstance.attributes['cn'] = groupInstance.changes[
'set']['cn']
self.backend.updateObject(
groupTemplate, groupInstance, {
'changes': {
'set': {
'cn': [groupInstance.displayName]
},
'type': -1
}
})
###############################################
elif groupInstance.changes[
'type'] == OBJECT_CHANGE_DELETE_OBJECT:
print " |-> Group '\033[35m" + groupInstance.displayName + "' is \033[33mdeleting\033[0m..."
self._deleteObject(groupTemplate, groupInstance)
print " End."
class LBEObjectInstanceHelper(object):
def __init__(self, lbeObjectTemplate, lbeObjectInstance=None):
self.template = lbeObjectTemplate
self.instance = lbeObjectInstance
self.scriptInstance = None
self.backend = None
def _backend(self):
if self.backend is not None:
return
self.backend = BackendHelper()
"""
LOAD Script
"""
def _load_script(self):
if self.scriptInstance is not None:
return
# if lbeObjectTemplate.script is defined, create an instance
scriptName = self.template.script.name
if scriptName is not None:
# the scriptName is like 'custom.employee.EmployeePostConfig', so we need to extract the module, aka custom.employee
moduleName = '.'.join(scriptName.split('.')[:-1])
# and the classname, EmployeePostConfig
className = scriptName.split('.')[-1]
__import__(moduleName)
module = sys.modules[moduleName]
self.scriptClass = getattr(module, className)
# Create an instance
#self.scriptInstance = self.scriptClass(self.template,self.instance)
else:
logging.error('This object does not have an associate script')
def _create_script_instance(self, data=None):
self._load_script()
if self.scriptInstance is not None:
return
self.scriptInstance = self.scriptClass(self.template, self.instance, data)
"""
END LOAD Script
"""
"""
DE/COMPRESS Datas:
"""
def _compress_data(self, data):
query = {}
for key in data:
if len(data.getlist(key)) == 1:
query[key] = data[key]
else: # compress MultiValue:
query[key] = '\0'.join(str(val) for val in data.getlist(key))
return query
def decompress_data(self, data):
query = {}
for key in data:
if len(data.getlist(key)) == 1:
query[key] = data[key]
else: # decompress MultiValue:
query[key] = data[key].split('\0')
return query
"""
END DE/COMPRESS Datas
"""
"""
MANAGE Object/Values:
"""
def save(self, ):
self._checkUnique()
# Search for an existing object
searchResult = self.backend.getUserForObject(self.template, self.instance.name)
if searchResult is None:
return self.backend.createObject(self.template, self.instance)
else:
raise BackendObjectAlreadyExist('Already exists')
def update(self):
self._checkUnique()
self.backend.createObject(self.template, self.instance.changes['set'])
def getStatus(self, objectName):
self._backend()
return self.backend.getStatus(self.template, objectName)
def modify(self):
self._checkUnique()
if not self.backend.getStatus(self.template, self.instance.name) == OBJECT_STATE_AWAITING_RECONCILIATION:
self.backend.modifyObject(self.template, self.instance.name, self.instance.changes['set'],
self.instance.displayName)
else:
raise TypeError("In order to change the Object, Your administrator needs to launch reconciliation first.")
def remove(self, uid):
self._backend()
return self.backend.removeObject(self.template, uid)
def approval(self, uid):
self._backend()
return self.backend.approvalObject(self.template, uid)
def form(self, uid, data=None):
if data is None:
data = self.getValues(uid)
else:
data = self._compress_data(data)
self._create_script_instance(data)
return self.scriptInstance
"""
END MANAGE Object/Values:
"""
"""
CALL Script
"""
def callScriptMethod(self, methodName):
self._create_script_instance()
method = getattr(self.scriptInstance, methodName)
return method()
def callScriptClassMethod(self, methodName):
self._load_script()
method = getattr(self.scriptClass, methodName)
return method()
def callAttributeScriptMethod(self, attributeType, methodPrefix):
for attributeInstance in self.template.lbeattributeinstance_set.filter(attributeType=attributeType):
attributeName = attributeInstance.lbeAttribute.name
try:
if not self.instance.changes['set'] == {}:
self.instance.changes['set'][attributeName] = self.callScriptMethod(methodPrefix + attributeName)
else:
self.instance.attributes[attributeName] = self.callScriptMethod(methodPrefix + attributeName)
except AttributeError as e:
try:
self.instance[attributeName] = self.callScriptMethod(methodPrefix + attributeName)
except AttributeError as e:
logger.info(
'LBEObjectInstanceHelper: Method ' + methodPrefix + attributeName + ' not found or AttributeError exception. ' + e.__str__())
print (
'LBEObjectInstanceHelper: Method ' + methodPrefix + attributeName + ' not found or AttributeError exception. ' + e.__str__())
def applyCustomScript(self):
# Clean attributes before manage virtuals attributes
#self.callAttributeScriptMethod(ATTRIBUTE_TYPE_FINAL, 'clean_')
# Now, compute virtual attributes
self.callAttributeScriptMethod(ATTRIBUTE_TYPE_VIRTUAL, 'compute_')
def applyCustomScriptAttribute(self, attribute):
try:
attributeInstance = self.template.lbeattributeinstance_set.get(attributeType=ATTRIBUTE_TYPE_FINAL,
lbeAttribute=LBEAttribute.objects.get(
name__iexact=attribute))
self.instance[attributeInstance.lbeAttribute.name] = self.callScriptMethod(
"clean_" + attributeInstance.lbeAttribute.name)
except BaseException as e:
print e
"""
END CALL Script
"""
def _checkUnique(self):
self._backend()
attributesInstance = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template, unique=True)
objectInstances = self.backend.searchObjects(self.template)
for attribute in attributesInstance:
for obj in objectInstances:
if not obj.changes['set'] == {}:
if obj.changes['set'].has_key(attribute.lbeAttribute.name) and self.instance.changes['set'].has_key(
attribute.lbeAttribute.name) \
and not self.instance.name == obj.name:
# MultiValue:
for objAttribute in obj.changes['set'][attribute.lbeAttribute.name]:
for instanceAttribute in self.instance.changes['set'][attribute.lbeAttribute.name]:
if objAttribute == instanceAttribute:
raise ValueError("The value '" + str(
self.instance.changes['set'][attribute.lbeAttribute.name][
0]) + "' from the '" + attribute.lbeAttribute.name + "' attribute must be unique.\nPlease change its value or their computed values.")
else:
if obj.attributes.has_key(attribute.lbeAttribute.name) and self.instance.changes['set'].has_key(
attribute.lbeAttribute.name) \
and not self.instance.name == obj.name:
# MultiValue:
for objAttribute in obj.attributes[attribute.lbeAttribute.name]:
for instanceAttribute in self.instance.changes['set'][attribute.lbeAttribute.name]:
if objAttribute == instanceAttribute:
raise ValueError("The value '" + str(
self.instance.changes['set'][attribute.lbeAttribute.name][
0]) + "' from the '" + attribute.lbeAttribute.name + "' attribute must be unique.\nPlease change its value or their computed values.")
def getValues(self, UID):
"""
Function enables to get values from attributes fields and
changes.set fields, return the new values (changes.set > attributes)
"""
try:
self._backend()
valuesUser = self.backend.getUserForObject(self.template, UID)
# Get all attributes from objects:
attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template)
d = dict()
for attribute in attributes:
# Only FINAL Attributes:
if attribute.attributeType == 0:
try:
if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name):
q = QueryDict(attribute.lbeAttribute.name + '=' +
valuesUser['changes']['set'][attribute.lbeAttribute.name][0])
q = q.copy()
for value in valuesUser['changes']['set'][attribute.lbeAttribute.name][1:]:
q.update({attribute.lbeAttribute.name: value})
d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
else:
q = QueryDict(attribute.lbeAttribute.name + '=' +
valuesUser['attributes'][attribute.lbeAttribute.name][0])
q = q.copy()
for value in valuesUser['attributes'][attribute.lbeAttribute.name][1:]:
q.update({attribute.lbeAttribute.name: value})
d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
except BaseException:
d[attribute.lbeAttribute.name] = attribute.defaultValue
return d
except BaseException:
# Create part:
return None
def getObject(self, UID):
self._backend()
return self.backend.searchObjectsByPattern(self.template, UID)[0]
def searchPattern(self, pattern):
self._backend()
objects = self.backend.searchObjects(self.template)
tabResult = []
prog = re.compile(pattern, re.I)
for object in objects:
# check the status object & get its values
if object.status == OBJECT_STATE_AWAITING_SYNC:
objectValues = object.changes['set']
else:
objectValues = object.attributes
# check values and pattern corresponding
correspond = ''
for key, values in objectValues.items():
for cel in values:
if prog.search(cel):
attributeDisplayName = LBEAttribute.objects.get(name__iexact=key).displayName
correspond += cel.lower().replace(pattern, '<b>' + pattern + '</b>') + ' (<i>' + attributeDisplayName + '</i>) '
if correspond:
tabResult.append({'object': self.template.id, "name": object.name, 'displayName': object.displayName,
"values": correspond})
return tabResult
def getValuesDecompressed(self, UID):
"""
Function enables to get values from attributes fields and
changes.set fields, return the new values (changes.set > attributes)
"""
self._backend()
valuesUser = self.backend.getUserForObject(self.template, UID)
# Get all attributes from objects:
attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template).order_by('position')
d = dict()
for attribute in attributes:
try:
if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name):
d[attribute.lbeAttribute.name] = valuesUser['changes']['set'][attribute.lbeAttribute.name]
else:
d[attribute.lbeAttribute.name] = valuesUser['attributes'][attribute.lbeAttribute.name]
except KeyError:
# if no values, just set the default value:
d[attribute.lbeAttribute.name] = attribute.defaultValue
return d
def createFromDict(self, request):
# Reinit script configuration file:
self.scriptInstance = None
# attributes:
attributes = {}
for attributeInstance in self.template.lbeattributeinstance_set.all():
# Only fetch real attributes from the request (mono and/or multi values)
if attributeInstance.attributeType == ATTRIBUTE_TYPE_FINAL:
attributeName = attributeInstance.lbeAttribute.name
if len(request.POST[attributeName].split('�')) > 1:
attributes[attributeName] = request.POST[attributeName].split('�')
else:
attributes[attributeName] = [request.POST[attributeName]]
# IMPORTANT: We need to create an instance without the uniqueBecause because it may be a computed attribute, for example uid (compute from firstname/name)
self.instance = LBEObjectInstance(self.template, attributes=attributes)
self.instance.status = OBJECT_STATE_AWAITING_SYNC
self.applyCustomScript()
# Set uniqueName and displayName
try:
self.instance.name = self.instance.attributes[self.template.instanceNameAttribute.name][0]
self.instance.displayName = self.instance.attributes[self.template.instanceDisplayNameAttribute.name][0]
# It's a new object, the changesSet apply to all attributes
self.instance.changes['type'] = OBJECT_CHANGE_CREATE_OBJECT
self.instance.changes['set'] = self.instance.attributes
except BaseException as e:
print e.__str__()
# TODO: Remove technical message, use another handler to send message to administrator
messages.add_message(request, messages.ERROR,
'nameAttribute or displayNameAttribute does not exist in object attributes')
def updateFromDict(self, ID, values):
self.scriptInstance = None
self.instance = LBEObjectInstance(self.template, attributes=None)
self.instance.changes['set'] = values
self.instance.attributes = values
# compute attributes:
self._create_script_instance()
self.applyCustomScript()
# set them (if not been yet) to array:
for key in self.instance.attributes:
if isinstance(self.instance.attributes[key], str) or isinstance(self.instance.attributes[key], unicode):
self.instance.attributes[key] = [self.instance.attributes[key]]
# change the displayName value:
self.instance.displayName = self.instance.changes['set'][self.template.instanceDisplayNameAttribute.name][0]
# ID object:
self.instance.name = ID
def compute(self, lbeObjectInstance):
self.instance = lbeObjectInstance
self._create_script_instance()
# Do not make change if changes.set is empty:
if not lbeObjectInstance.changes['set'] == {}:
self.applyCustomScript()
def _executePerson(self, userID):
# backend db:
backend = BackendHelper()
obj = backend.getUserUIDForObject(self.object, userID)
# check if characters:
if self.word[3] != '':
# split ',' values:
val = self.word[3].split(',')
try:
for value in obj['attributes'][self.attribute]:
for attrValue in val:
if self.operator == '=':
if attrValue == value:
return True
elif self.operator == '!=':
if attrValue == value:
return False
except BaseException as e:
# e
# attribute does not exist for user:
pass
return self.operator == '!='
# only a number:
elif self.number:
try:
if self.operator == '=':
number = self.number.split(',')
for nb in number:
if int(nb) == int(
obj['attributes'][self.attribute][0]):
return True
return False
elif self.operator == '!=':
number = self.number.split(',')
for nb in number:
if int(nb) == int(
obj['attributes'][self.attribute][0]):
return False
return True
elif self.operator == '>':
return int(
obj['attributes'][self.attribute][0]) > self.number
elif self.operator == '<':
return int(
obj['attributes'][self.attribute][0]) < self.number
elif self.operator == '<=':
return int(
obj['attributes'][self.attribute][0]) <= self.number
elif self.operator == '>=':
return int(
obj['attributes'][self.attribute][0]) >= self.number
except:
# wrong key
self.traceback = "The key " + self.attribute + "does not exist to the Backend Server for " + userID + "."
return False
# number range:
elif self.numberTo and self.numberFrom:
try:
if self.operator == '=':
return self.numberTo <= int(obj['attributes'][self.attribute][0]) and \
self.numberFrom >= int(obj['attributes'][self.attribute][0])
elif self.operator == '!=':
return self.numberTo <= int(obj['attributes'][self.attribute][0]) and \
self.numberFrom >= int(obj['attributes'][self.attribute][0])
except:
# wrong key
self.traceback = "The key " + self.attribute + "does not exist to the Backend Server for " + userID + "."
return False
# not necessary:
return False
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
def modifyObject(request, obj_id=None, instance_id=None):
objectForm = None
lbeObjectTemplate = LBEObjectTemplate.objects.get(id=obj_id)
if request.method == 'POST':
# we can't modify the Synced_at value
POST = request.POST.copy()
POST['synced_at'] = lbeObjectTemplate.synced_at
# POST modification
objectForm = LBEObjectTemplateForm(POST, instance=lbeObjectTemplate)
oldNAttribute = lbeObjectTemplate.instanceNameAttribute.name
oldDNAttribute = lbeObjectTemplate.instanceDisplayNameAttribute.id
if objectForm.is_valid():
# change the _id value if changed:
if not oldNAttribute == request.POST['instanceNameAttribute']:
changeID = True
else:
changeID = False
# change the displayName value if changed:
if not oldDNAttribute == int(request.POST['instanceDisplayNameAttribute']):
DN = True
else:
DN = False
if changeID or DN:
if changeID is True:
objectForm.instance.instanceNameBeforeAttribute = LBEAttribute.objects.get(
name__iexact=oldNAttribute)
objectForm.instance.needReconciliationRDN = True
backend = BackendHelper()
ob = backend.searchObjects(lbeObjectTemplate)
try:
for o in ob:
if changeID:
# change the _id value
backend.update_id(lbeObjectTemplate, o,
o.attributes[request.POST['instanceNameAttribute']][0])
# the RDN Attribute from Target Server is replace into the Reconciliation
if DN:
attribute = LBEAttribute.objects.get(id=request.POST['instanceDisplayNameAttribute'])
backend.modifyDisplayName(lbeObjectTemplate, o.name, o.attributes[attribute.name][0])
# Groups
if changeID:
groups = LBEGroup.objects.filter(objectTemplate=lbeObjectTemplate)
for group in groups:
InstanceHelper = GroupInstanceHelper(group)
InstanceHelper.changeIDObjects()
except KeyError:
messages.add_message(request, messages.ERROR, 'Error while saving object, "' + request.POST[
'instanceNameAttribute'] + '" does not exist for the Object.')
return redirect('/config/object/modify/' + obj_id)
objectForm.save()
messages.add_message(request, messages.SUCCESS, 'Object saved')
return redirect('/config/object/modify/' + obj_id)
else:
messages.add_message(request, messages.ERROR, 'Error while saving object.')
else:
if obj_id is None:
messages.add_message(request, messages.INFO, 'Object id is missing.')
return render_to_response('config/object/list.html', {'objects': LBEObjectTemplate.objects.all()})
else:
objectForm = LBEObjectTemplateForm(instance=lbeObjectTemplate)
attForm = LBEAttributeInstanceForm()
instances = LBEAttributeInstance.objects.filter(lbeObjectTemplate=lbeObjectTemplate).order_by('position')
# which attribute have ajax request:
ajaxAttribute = 'instanceNameAttribute'
defaultValue = lbeObjectTemplate.instanceNameAttribute.name
# Ajax function to call (js):
ajaxFunction = 'selectFrom(\'' + reverse('config.views.showAttributeAJAX')[:-1] + '\',\'' + ajaxAttribute + '\');'
info_missing_policy = "Variable used for setting if the Object is deleted into the Target or <br> if we need to add "
info_missing_policy += " to the Backend"
info_different_policy = "Variable enables to set which Server, we need to upgrade values:<br> If the value is TARGET"
info_different_policy += ", then the Backend object will replace the Target object <br>else, the opposite."
if lbeObjectTemplate.instanceNameBeforeAttribute is not None:
attributeBefore = lbeObjectTemplate.instanceNameBeforeAttribute.name
else:
attributeBefore = lbeObjectTemplate.instanceNameAttribute.name
return render_to_response('config/object/modify.html',
{'attributeInstances': instances, 'lbeObject': lbeObjectTemplate,
'objectForm': objectForm, 'attributeForm': attForm, 'ajaxAttribute': ajaxAttribute,
'ajaxFunction': ajaxFunction, 'defaultValue': defaultValue,
'info_missing_policy': info_missing_policy,
'info_different_policy': info_different_policy,
'attributeInstanceBefore': attributeBefore},
context_instance=RequestContext(request))
def _executePerson(self, userID):
# backend db:
backend = BackendHelper()
obj = backend.getUserUIDForObject(self.object, userID)
# check if characters:
if self.word[3] != '':
# split ',' values:
val = self.word[3].split(',')
try:
for value in obj['attributes'][self.attribute]:
for attrValue in val:
if self.operator == '=':
if attrValue == value:
return True
elif self.operator == '!=':
if attrValue == value:
return False
except BaseException as e:
# e
# attribute does not exist for user:
pass
return self.operator == '!='
# only a number:
elif self.number:
try:
if self.operator == '=':
number = self.number.split(',')
for nb in number:
if int(nb) == int(obj['attributes'][self.attribute][0]):
return True
return False
elif self.operator == '!=':
number = self.number.split(',')
for nb in number:
if int(nb) == int(obj['attributes'][self.attribute][0]):
return False
return True
elif self.operator == '>':
return int(obj['attributes'][self.attribute][0]) > self.number
elif self.operator == '<':
return int(obj['attributes'][self.attribute][0]) < self.number
elif self.operator == '<=':
return int(obj['attributes'][self.attribute][0]) <= self.number
elif self.operator == '>=':
return int(obj['attributes'][self.attribute][0]) >= self.number
except:
# wrong key
self.traceback = "The key " + self.attribute + "does not exist to the Backend Server for " + userID + "."
return False
# number range:
elif self.numberTo and self.numberFrom:
try:
if self.operator == '=':
return self.numberTo <= int(obj['attributes'][self.attribute][0]) and \
self.numberFrom >= int(obj['attributes'][self.attribute][0])
elif self.operator == '!=':
return self.numberTo <= int(obj['attributes'][self.attribute][0]) and \
self.numberFrom >= int(obj['attributes'][self.attribute][0])
except:
# wrong key
self.traceback = "The key " + self.attribute + "does not exist to the Backend Server for " + userID + "."
return False
# not necessary:
return False
class ImportTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _getID(self, listRDN):
listID = []
for rdn in listRDN:
listID.append(rdn.split('=')[1].split(',')[0])
return listID
def save(self):
print 'Checking for Objects which do not exist into LBE Backend but in LDAP Server:'
for objectTemplate in LBEObjectTemplate.objects.all():
objectHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objectHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
filter = '(&'
for oc in objectHelper.callScriptClassMethod('object_classes'):
filter += '(objectClass=' + oc + ')'
filter += ')'
print '\033[91m' + objectTemplate.name + '\033[0m: (\033[95m' + objectHelper.callScriptClassMethod("base_dn") + '\033[0m) using \033[95m' + filter + '\033[0m'
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
number = 0
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
exist = True
break
if not exist:
number += 1
print '=> Adding \033[95m' + ot.name + '\033[0m object into LBE Backend... '
print " values: " + str(ot.attributes)
try:
self.backend.createObject(objectTemplate, ot, True)
print "\033[92mDone.\033[0m\n"
except BaseException as e:
print "\033[91mFail.\033[0m"
print "''''''''"
print e
print "''''''''"
if number == 0:
print '<None>'
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print '.........................'
print 'Checking for Groups which do not exist into LBE Backend but in Target:'
for groupTemplate in LBEGroup.objects.all():
groupInstance = GroupInstanceHelper(groupTemplate)
try:
scope = groupInstance.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
grpTarget = self.target.searchObjects(groupTemplate, scope)
grpBackend = self.backend.searchObjects(groupTemplate)
for gt in grpTarget:
exist = False
for gb in grpBackend:
if gt.name == gb.name:
exist = True
break
if not exist:
# import only existing group into LBE config
try:
LBEGroup.objects.get(displayName__iexact=gt.displayName)
except BaseException:
continue
print '=> Adding \033[95m' + gt.name + '\033[0m group into LBE Backend... '
print " values: " + str(gt.attributes)
try:
if groupInstance.attributeName in gt.attributes:
gt.attributes[groupInstance.attributeName] = self._getID(gt.attributes[groupInstance.attributeName])
groupHelper = GroupInstanceHelper(groupTemplate, gt)
groupHelper.createTemplate(True)
#print " >\033[91mThis group does not exists in LBE Configuration Group.\033[0m"
#print " >\033[91mIn order to see, manage it, please create it using some extra attribute:"
#print " >\033[91m'Display Name': \033[95m" + gt.name + "\033[0m"
#print " >\033[91mInto the Script file:"
#print " >'DN Attribute': \033[95m" + groupHelper.callScriptClassMethod("base_dn") + "\033[91m"
#print " >'Attribute Name' & 'Object Classes': as you wish.\033[0m"
print "\033[92mDone.\033[0m\n"
except BaseException as e:
print "\033[91mFail.\033[0m\n"
print "''''''''"
print e
print "''''''''"
# Synced group:
groupTemplate.synced_at = django.utils.timezone.now()
groupTemplate.save()
print "End."
class UpgradeBT():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _deleteORCreate(self, objectTemplate, ot):
if objectTemplate.reconciliation_object_missing_policy == OBJECT_ADD_BACKEND:
print " |-> Adding \033[95m'" + ot.displayName + "'\033[0m object into Backend... "
try:
self.backend.createObject(objectTemplate, ot, True)
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, ot, changes)
except BaseException as e:
print "''''''''"
print e
print "''''''''"
elif objectTemplate.reconciliation_object_missing_policy == OBJECT_DELETE_TARGET:
print " |-> Removing \033[95m'" + ot.displayName + "'\033[0m object from Target... "
try:
self.target.delete(objectTemplate, ot)
except BaseException as e:
print "''''''''"
print e
print "''''''''"
def _upgradeObject(self, objectTemplate, objHelper, ot, ob):
# check and replace ignore attributes:
ignoreAttributes = objHelper.callScriptClassMethod("ignore_attributes")
for key, values in ot.attributes.items():
if key in ignoreAttributes:
ob.attributes[key] = ot.attributes[key]
if not ot.attributes == ob.attributes:
if objectTemplate.reconciliation_object_different_policy == TARGET:
# check if values are empty []:
# Then, skip it.
numberEmpty = 0
for values in set(ot.attributes) ^ set(ob.attributes):
try:
# either empty or empty string:
if ob.attributes[values] == [] or ob.attributes[values] == ['']:
numberEmpty += 1
except BaseException:
pass
if not numberEmpty == 0 and numberEmpty == len(set(ot.attributes) ^ set(ob.attributes)):
return
print " |-> Upgrade Object '\033[35m" + ob.displayName + "\033[0m' into Target..."
print " |-> -------------------------------------------- "
print " ||-> Old Values: " + str(ot.attributes)
print " ||-> New Values: " + str(ob.attributes)
print " |-> -------------------------------------------- "
# Remove & Add in order to add new attributes:
try:
# Remove:
self.target.delete(objectTemplate, ob)
# Add
self.target.create(objectTemplate, ob)
# Synced:
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, ob, changes)
except BaseException as e:
print e
elif objectTemplate.reconciliation_object_different_policy == BACKEND:
print " |-> Upgrade Object '\033[35m" + ob.displayName + "\033[0m' into Backend..."
print " |-> -------------------------------------------- "
print " ||-> Old Values: " + str(ob.attributes)
print " ||-> New Values: " + str(ot.attributes)
print " |-> -------------------------------------------- "
try:
self.backend.updateObject(objectTemplate, ob, ot)
except BaseException as e:
print e
def start(self):
print " Upgrade Server..."
for objectTemplate in LBEObjectTemplate.objects.all():
print " |-> \033[91m" + objectTemplate.name + '\033[0m:'
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
# Target to Backend:
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
self._upgradeObject(objectTemplate, objHelper, ot, ob)
exist = True
break
if not exist:
self._deleteORCreate(objectTemplate, ot)
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print " End."
def _backend(self):
if self.backend is not None:
return
self.backend = BackendHelper()
class DebugTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
"""
Check which values' objects need to be sync and show them.
"""
def _needModification(self):
print ' Objects need change:'
number = 0
for objectTemplate in LBEObjectTemplate.objects.all():
# We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC
for objectInstance in self.backend.searchObjectsToUpdate(
objectTemplate):
type = ""
if objectInstance.changes[
'type'] == OBJECT_CHANGE_CREATE_OBJECT:
type += "\033[34mcreate"
elif objectInstance.changes[
'type'] == OBJECT_CHANGE_UPDATE_OBJECT:
type += "\033[36mupdate"
elif objectInstance.changes[
'type'] == OBJECT_CHANGE_DELETE_OBJECT:
type += "\033[33mdelete"
type += "\033[0m"
value = " " + type + ' \033[35m' + objectInstance.displayName + '\033[0m : '
valuesChanges = dict()
for k in objectInstance.changes['set']:
try:
if objectInstance.attributes[
k] != objectInstance.changes['set'][k]:
valuesChanges[k] = 'new Value: ' + str(
objectInstance.changes['set']
[k]) + ' | old value: ' + str(
objectInstance.attributes[k])
except KeyError:
valuesChanges[k] = 'new Value: ' + str(
objectInstance.changes['set'][k])
pass
print value + str(valuesChanges)
number += 1
if number == 0:
print " \033[91m<None>\033[0m"
print ""
print ' Groups need change:'
number = 0
for groupTemplate in LBEGroup.objects.all():
for groupInstance in self.backend.searchObjectsToUpdate(
groupTemplate):
number += 1
type = ""
if groupInstance.changes[
'type'] == OBJECT_CHANGE_CREATE_OBJECT:
type += "\033[34mcreate"
elif groupInstance.changes[
'type'] == OBJECT_CHANGE_UPDATE_OBJECT:
type += "\033[36mupdate"
elif groupInstance.changes[
'type'] == OBJECT_CHANGE_DELETE_OBJECT:
type += "\033[33mdelete"
type += "\033[0m"
value = " " + type + ' \033[35m' + groupInstance.displayName + '\033[0m : '
valuesChanges = dict()
for k in groupInstance.changes['set']:
try:
if groupInstance.attributes[
k] != groupInstance.changes['set'][k]:
valuesChanges[k] = 'new Value: ' + str(
groupInstance.changes['set']
[k]) + ' | old value: ' + str(
groupInstance.attributes[k])
except KeyError:
valuesChanges[k] = 'new Value: ' + str(
groupInstance.changes['set'][k])
pass
print value + str(valuesChanges)
if number == 0:
print " \033[91m<None>\033[0m"
"""
Show objects do not exist in LBE but LDAP.
"""
def _notExistObjectLBE(self):
print ' Checking for Objects which do not exist into LBE but in LDAP Server:'
for objectTemplate in LBEObjectTemplate.objects.all():
print " - \033[35m" + objectTemplate.name + '\033[0m...'
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
number = 0
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
exist = True
break
if not exist:
number += 1
print " " + ot.name
if number == 0:
print ' \033[91m<None>\033[0m'
print ""
print ' Checking for Groups which do not exist into LBE but in LDAP Server:'
number = 0
for groupTemplate in LBEGroup.objects.all():
grpHelper = GroupInstanceHelper(groupTemplate)
try:
scope = grpHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
grpTarget = self.target.searchObjects(
groupTemplate, scope, '(cn=' + groupTemplate.displayName + ')')
grpBackend = self.backend.searchObjectsByPattern(
groupTemplate, groupTemplate.displayName)
if not grpBackend:
print " - \033[36m" + groupTemplate.displayName + "\033[0m does not exists."
number += 1
if number == 0:
print ' \033[91m<None>\033[0m'
def start(self):
self._needModification()
print ""
print '\033[93m.........................\033[0m'
print '\033[93m.........................\033[0m'
print ""
self._notExistObjectLBE()
class ImportTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _getID(self, listRDN):
listID = []
for rdn in listRDN:
listID.append(rdn.split('=')[1].split(',')[0])
return listID
def save(self):
print 'Checking for Objects which do not exist into LBE Backend but in LDAP Server:'
for objectTemplate in LBEObjectTemplate.objects.all():
objectHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objectHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
filter = '(&'
for oc in objectHelper.callScriptClassMethod('object_classes'):
filter += '(objectClass=' + oc + ')'
filter += ')'
print '\033[91m' + objectTemplate.name + '\033[0m: (\033[95m' + objectHelper.callScriptClassMethod(
"base_dn") + '\033[0m) using \033[95m' + filter + '\033[0m'
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
number = 0
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
exist = True
break
if not exist:
number += 1
print '=> Adding \033[95m' + ot.name + '\033[0m object into LBE Backend... '
print " values: " + str(ot.attributes)
try:
self.backend.createObject(objectTemplate, ot, True)
print "\033[92mDone.\033[0m\n"
except BaseException as e:
print "\033[91mFail.\033[0m"
print "''''''''"
print e
print "''''''''"
if number == 0:
print '<None>'
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print '.........................'
print 'Checking for Groups which do not exist into LBE Backend but in Target:'
for groupTemplate in LBEGroup.objects.all():
groupInstance = GroupInstanceHelper(groupTemplate)
try:
scope = groupInstance.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
grpTarget = self.target.searchObjects(groupTemplate, scope)
grpBackend = self.backend.searchObjects(groupTemplate)
for gt in grpTarget:
exist = False
for gb in grpBackend:
if gt.name == gb.name:
exist = True
break
if not exist:
# import only existing group into LBE config
try:
LBEGroup.objects.get(
displayName__iexact=gt.displayName)
except BaseException:
continue
print '=> Adding \033[95m' + gt.name + '\033[0m group into LBE Backend... '
print " values: " + str(gt.attributes)
try:
if groupInstance.attributeName in gt.attributes:
gt.attributes[
groupInstance.attributeName] = self._getID(
gt.attributes[groupInstance.attributeName])
groupHelper = GroupInstanceHelper(groupTemplate, gt)
groupHelper.createTemplate(True)
#print " >\033[91mThis group does not exists in LBE Configuration Group.\033[0m"
#print " >\033[91mIn order to see, manage it, please create it using some extra attribute:"
#print " >\033[91m'Display Name': \033[95m" + gt.name + "\033[0m"
#print " >\033[91mInto the Script file:"
#print " >'DN Attribute': \033[95m" + groupHelper.callScriptClassMethod("base_dn") + "\033[91m"
#print " >'Attribute Name' & 'Object Classes': as you wish.\033[0m"
print "\033[92mDone.\033[0m\n"
except BaseException as e:
print "\033[91mFail.\033[0m\n"
print "''''''''"
print e
print "''''''''"
# Synced group:
groupTemplate.synced_at = django.utils.timezone.now()
groupTemplate.save()
print "End."
def modifyObject(request, obj_id=None, instance_id=None):
objectForm = None
lbeObjectTemplate = LBEObjectTemplate.objects.get(id=obj_id)
if request.method == 'POST':
# we can't modify the Synced_at value
POST = request.POST.copy()
POST['synced_at'] = lbeObjectTemplate.synced_at
# POST modification
objectForm = LBEObjectTemplateForm(POST, instance=lbeObjectTemplate)
oldNAttribute = lbeObjectTemplate.instanceNameAttribute.name
oldDNAttribute = lbeObjectTemplate.instanceDisplayNameAttribute.id
if objectForm.is_valid():
# change the _id value if changed:
if not oldNAttribute == request.POST['instanceNameAttribute']:
changeID = True
else:
changeID = False
# change the displayName value if changed:
if not oldDNAttribute == int(
request.POST['instanceDisplayNameAttribute']):
DN = True
else:
DN = False
if changeID or DN:
if changeID is True:
objectForm.instance.instanceNameBeforeAttribute = LBEAttribute.objects.get(
name__iexact=oldNAttribute)
objectForm.instance.needReconciliationRDN = True
backend = BackendHelper()
ob = backend.searchObjects(lbeObjectTemplate)
try:
for o in ob:
if changeID:
# change the _id value
backend.update_id(
lbeObjectTemplate, o, o.attributes[
request.POST['instanceNameAttribute']][0])
# the RDN Attribute from Target Server is replace into the Reconciliation
if DN:
attribute = LBEAttribute.objects.get(
id=request.POST['instanceDisplayNameAttribute']
)
backend.modifyDisplayName(
lbeObjectTemplate, o.name,
o.attributes[attribute.name][0])
# Groups
if changeID:
groups = LBEGroup.objects.filter(
objectTemplate=lbeObjectTemplate)
for group in groups:
InstanceHelper = GroupInstanceHelper(group)
InstanceHelper.changeIDObjects()
except KeyError:
messages.add_message(
request, messages.ERROR,
'Error while saving object, "' +
request.POST['instanceNameAttribute'] +
'" does not exist for the Object.')
return redirect('/config/object/modify/' + obj_id)
objectForm.save()
messages.add_message(request, messages.SUCCESS, 'Object saved')
return redirect('/config/object/modify/' + obj_id)
else:
messages.add_message(request, messages.ERROR,
'Error while saving object.')
else:
if obj_id is None:
messages.add_message(request, messages.INFO,
'Object id is missing.')
return render_to_response(
'config/object/list.html',
{'objects': LBEObjectTemplate.objects.all()})
else:
objectForm = LBEObjectTemplateForm(instance=lbeObjectTemplate)
attForm = LBEAttributeInstanceForm()
instances = LBEAttributeInstance.objects.filter(
lbeObjectTemplate=lbeObjectTemplate).order_by('position')
# which attribute have ajax request:
ajaxAttribute = 'instanceNameAttribute'
defaultValue = lbeObjectTemplate.instanceNameAttribute.name
# Ajax function to call (js):
ajaxFunction = 'selectFrom(\'' + reverse(
'config.views.showAttributeAJAX'
)[:-1] + '\',\'' + ajaxAttribute + '\');'
info_missing_policy = "Variable used for setting if the Object is deleted into the Target or <br> if we need to add "
info_missing_policy += " to the Backend"
info_different_policy = "Variable enables to set which Server, we need to upgrade values:<br> If the value is TARGET"
info_different_policy += ", then the Backend object will replace the Target object <br>else, the opposite."
if lbeObjectTemplate.instanceNameBeforeAttribute is not None:
attributeBefore = lbeObjectTemplate.instanceNameBeforeAttribute.name
else:
attributeBefore = lbeObjectTemplate.instanceNameAttribute.name
return render_to_response('config/object/modify.html', {
'attributeInstances': instances,
'lbeObject': lbeObjectTemplate,
'objectForm': objectForm,
'attributeForm': attForm,
'ajaxAttribute': ajaxAttribute,
'ajaxFunction': ajaxFunction,
'defaultValue': defaultValue,
'info_missing_policy': info_missing_policy,
'info_different_policy': info_different_policy,
'attributeInstanceBefore': attributeBefore
},
context_instance=RequestContext(request))
class UpgradeTarget:
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _changeClass(self, objectTemplate):
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("scope_search")
except BaseException:
scope = 0
ob = self.backend.searchObjects(objectTemplate)
for objectInstance in ob:
try:
oldClasses = self.target.getInstanceObjectClasses(objectTemplate, objectInstance, scope)
except ldap.NO_SUCH_OBJECT:
continue
newClasses = objHelper.callScriptClassMethod("object_classes")
if not sorted(oldClasses) == sorted(newClasses):
print " |-> The object classes have changed for '\033[35m" + objectInstance.displayName + "\033[0m'"
try:
self.target.changeClass(objectTemplate, objectInstance, oldClasses, newClasses)
except ldap.OBJECT_CLASS_VIOLATION as e:
print " *\033[91mError to modify the object class " + str(newClasses) + ", skip it.\033[0m"
print " *\033[91m" + e[0]["info"] + "\033[0m"
def _changeRDN(self, objectTemplate):
if objectTemplate.needReconciliationRDN:
print " |-> Upgrade the RDN Target server for \033[35m" + objectTemplate.name + "\033[0m..."
# Change the RDN Attribute to the Target Server
ob = self.backend.searchObjects(objectTemplate)
for o in ob:
try:
self.target.changeRDN(
objectTemplate,
o,
objectTemplate.instanceNameBeforeAttribute.name,
o.attributes[objectTemplate.instanceNameBeforeAttribute.name][0],
)
except BaseException:
# if object does not exists into the Target Server
pass
self.backend.updateStatus(objectTemplate, o.name)
# Update values for changing RDN attribute
objectTemplate.instanceNameBeforeAttribute = None
objectTemplate.needReconciliationRDN = False
objectTemplate.save()
print " |-> Done."
def _createParent(self, lbeObjectTemplate, objService):
base_dn = objService.callScriptClassMethod("base_dn")
objectToCreate = base_dn.replace(settings.LDAP_SERVER["BASE_DN"], "")[:-1].split(",")
objectToCreate.reverse()
for i in range(0, len(objectToCreate)):
dn = objectToCreate[i] + ","
for j in range(0, i):
dn = dn + objectToCreate[j] + ","
dn = dn + settings.LDAP_SERVER["BASE_DN"]
attrs = {}
attrs["objectclass"] = ["top", "organizationalUnit"]
# do not care if the ou already exists
try:
self.target.createParent(dn, modlist.addModlist(attrs))
except BaseException:
pass
def _createObject(self, objectTemplate, objectInstance):
self.target.create(objectTemplate, objectInstance)
# Ok, the object is added, empty changes set, and update object status
changes = {}
changes["status"] = OBJECT_STATE_SYNCED
changes["changes"] = {}
changes["changes"]["set"] = {}
changes["changes"]["type"] = -1
changes["synced_at"] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _modifyObject(self, objectTemplate, objectInstance, SCOPE):
rdnAttributeName = objectTemplate.instanceNameAttribute.name
self.target.update(objectTemplate, objectInstance, SCOPE)
if not objectInstance.attributes[rdnAttributeName][0] == objectInstance.changes["set"][rdnAttributeName][0]:
self.backend.update_id(objectTemplate, objectInstance, objectInstance.changes["set"][rdnAttributeName][0])
# Update Backend value:
changes = {}
changes["status"] = OBJECT_STATE_SYNCED
changes["changes"] = {}
changes["changes"]["set"] = {}
changes["changes"]["type"] = -1
changes["synced_at"] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _deleteObject(self, objectTemplate, objectInstance):
self.target.delete(objectTemplate, objectInstance)
# Update Backend value:
changes = {}
changes["status"] = OBJECT_STATE_DELETED
changes["changes"] = {}
changes["changes"]["set"] = {}
changes["changes"]["type"] = -1
changes["synced_at"] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
def _getRDN(self, objectTemplate, listID):
objectHelper = LBEObjectInstanceHelper(objectTemplate)
baseDN = objectHelper.callScriptClassMethod("base_dn")
listObjectID = []
for ID in listID:
dn = objectTemplate.instanceNameAttribute.name + "=" + ID + "," + baseDN
listObjectID.append(dn)
return listObjectID
def _getID(self, listRDN):
listID = []
for rdn in listRDN:
listID.append(rdn.split("=")[1].split(",")[0])
return listID
def start(self):
print " Upgrade the Target server with the Backend server..."
for objectTemplate in LBEObjectTemplate.objects.all():
# need to check if we need to change (before making reconciliation) the RDN attribute
self._changeRDN(objectTemplate)
# And the objects class
self._changeClass(objectTemplate)
# We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC
for objectInstance in self.backend.searchObjectsToUpdate(objectTemplate):
# First of all, applies all changes stored in backend [ such Virtual attributes ]
# & create the parent DN if not exist:
obj = LBEObjectInstanceHelper(objectTemplate, objectInstance)
try:
scope = obj.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
self._createParent(objectTemplate, obj)
# obj.compute(objectInstance)
# then, upgrade:
if objectInstance.changes["type"] == OBJECT_CHANGE_CREATE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "\033[0m' is \033[34mcreating\033[0m..."
self._createObject(objectTemplate, objectInstance)
# TODO: We should have a target exception rather ldap
except ldap.ALREADY_EXISTS:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m already exists"
changes = {}
changes["status"] = OBJECT_STATE_SYNCED
changes["changes"] = {}
changes["changes"]["set"] = {}
changes["changes"]["type"] = -1
changes["synced_at"] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
pass
elif objectInstance.changes["type"] == OBJECT_CHANGE_DELETE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "' is \033[33mdeleting\033[0m..."
self._deleteObject(objectTemplate, objectInstance)
except BaseException as e:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m does not exist."
changes = {}
changes["status"] = OBJECT_STATE_DELETED
changes["changes"] = {}
changes["changes"]["set"] = {}
changes["changes"]["type"] = -1
changes["synced_at"] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, objectInstance, changes)
pass
elif objectInstance.changes["type"] == OBJECT_CHANGE_UPDATE_OBJECT:
try:
print " |-> Object '\033[35m" + objectInstance.displayName + "'\033[0m is \033[36mupdating\033[0m..."
# Group
for group in LBEGroup.objects.all():
if group.objectTemplate.id == objectTemplate.id:
GroupInstanceHelper(group).updateMember(obj.getObject(obj.instance.name))
self._modifyObject(objectTemplate, objectInstance, scope)
except BaseException as e:
print e
print " |-> Object '\033[35m" + objectInstance.displayName + "' does not exist, being \033[34mcreated\033[0m..."
# Create object if not exists:
# Firstly, compute attributes values:
# Then, create it:
try:
self._createObject(objectTemplate, objectInstance)
except Exception as e:
print e
pass
pass
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print ""
print " Upgrade Groups Objects:"
for groupTemplate in LBEGroup.objects.all():
for groupInstance in self.backend.searchObjectsToUpdate(groupTemplate):
grp = GroupInstanceHelper(groupTemplate, groupInstance)
try:
scope = grp.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
self._createParent(groupTemplate, grp)
if groupInstance.changes["type"] == OBJECT_CHANGE_CREATE_OBJECT:
print " |-> Group '\033[35m" + groupInstance.displayName + "\033[0m' is \033[34mcreating\033[0m..."
try:
groupInstance.changes["set"][grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate, groupInstance.changes["set"][grp.attributeName]
)
self._createObject(groupTemplate, groupInstance)
###############################################
if not groupInstance.changes["set"] == {}:
groupInstance.changes["set"][grp.attributeName] = self._getID(
groupInstance.changes["set"][grp.attributeName]
)
groupInstance.attributes["cn"] = groupInstance.changes["set"]["cn"]
self.backend.updateObject(
groupTemplate,
groupInstance,
{"changes": {"set": {"cn": [groupInstance.displayName]}, "type": -1}},
)
###############################################
except ldap.ALREADY_EXISTS:
print " |-> Group '\033[35m" + groupInstance.displayName + "'\033[0m already exists"
elif groupInstance.changes["type"] == OBJECT_CHANGE_UPDATE_OBJECT:
try:
print " |-> Group '\033[35m" + groupInstance.displayName + "'\033[0m is \033[36mupdating\033[0m..."
groupInstance.changes["set"][grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate, groupInstance.changes["set"][grp.attributeName]
)
self._modifyObject(groupTemplate, groupInstance, scope)
###############################################
groupInstance.changes["set"][grp.attributeName] = self._getID(
groupInstance.changes["set"][grp.attributeName]
)
groupInstance.attributes["cn"] = groupInstance.changes["set"]["cn"]
self.backend.updateObject(
groupTemplate,
groupInstance,
{"changes": {"set": {"cn": [groupInstance.displayName]}, "type": -1}},
)
###############################################
except BaseException as e:
print e
print " |-> Group '\033[35m" + groupInstance.displayName + "' does not exist, being \033[34mcreated\033[0m..."
groupInstance.changes["set"][grp.attributeName] = self._getRDN(
groupTemplate.objectTemplate, groupInstance.changes["set"][grp.attributeName]
)
self._createObject(groupTemplate, groupInstance)
###############################################
groupInstance.changes["set"][grp.attributeName] = self._getID(
groupInstance.changes["set"][grp.attributeName]
)
groupInstance.attributes["cn"] = groupInstance.changes["set"]["cn"]
self.backend.updateObject(
groupTemplate,
groupInstance,
{"changes": {"set": {"cn": [groupInstance.displayName]}, "type": -1}},
)
###############################################
elif groupInstance.changes["type"] == OBJECT_CHANGE_DELETE_OBJECT:
print " |-> Group '\033[35m" + groupInstance.displayName + "' is \033[33mdeleting\033[0m..."
self._deleteObject(groupTemplate, groupInstance)
print " End."
def index(request):
objects = LBEObjectTemplate.objects.all()
groups = LBEGroup.objects.all()
backend = BackendHelper()
# Objects
statObjects = []
for object in objects:
lbeObjects = backend.searchObjects(object)
ok = 0
approval = 0
needSync = 0
delete = 0
reconciliation = False
for lbeobject in lbeObjects:
if lbeobject.status == 0:
ok += 1
elif lbeobject.status == 1:
needSync += 1
elif lbeobject.status == 2:
approval += 1
elif lbeobject.status == 3:
reconciliation = True
elif lbeobject.status == 4:
delete += 1
statObjects.append({
'name': object.displayName,
'total': len(lbeObjects),
'ok': ok,
'approval': approval,
'sync': needSync,
'reconciliation': reconciliation,
'delete': delete
})
# Groups
statGroups = []
try:
for group in groups:
groupHelper = GroupInstanceHelper(group)
groupHelper.get()
if groupHelper.attributeName in groupHelper.instance.changes['set'] and not \
groupHelper.instance.changes['set'][groupHelper.attributeName] == []:
total = len(groupHelper.instance.changes['set'][
groupHelper.attributeName])
else:
total = len(
groupHelper.instance.attributes[groupHelper.attributeName])
status = groupHelper.instance.status
except BaseException as e:
total = 0
status = -1
statGroups.append({
'name': group.displayName,
'total': total,
'object': groupHelper.template.objectTemplate.displayName,
'status': status
})
return render_to_response('directory/default/index.html', {
'objects': statObjects,
'groups': statGroups
},
context_instance=RequestContext(request))
def __init__(self):
self.backend = BackendHelper()
class DebugTarget():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
"""
Check which values' objects need to be sync and show them.
"""
def _needModification(self):
print ' Objects need change:'
number = 0
for objectTemplate in LBEObjectTemplate.objects.all():
# We're looking for all objects with state = OBJECT_STATE_AWAITING_SYNC
for objectInstance in self.backend.searchObjectsToUpdate(objectTemplate):
type = ""
if objectInstance.changes['type'] == OBJECT_CHANGE_CREATE_OBJECT:
type += "\033[34mcreate"
elif objectInstance.changes['type'] == OBJECT_CHANGE_UPDATE_OBJECT:
type += "\033[36mupdate"
elif objectInstance.changes['type'] == OBJECT_CHANGE_DELETE_OBJECT:
type += "\033[33mdelete"
type += "\033[0m"
value = " " + type + ' \033[35m' + objectInstance.displayName + '\033[0m : '
valuesChanges = dict()
for k in objectInstance.changes['set']:
try:
if objectInstance.attributes[k] != objectInstance.changes['set'][k]:
valuesChanges[k] = 'new Value: ' + str(
objectInstance.changes['set'][k]) + ' | old value: ' + str(
objectInstance.attributes[k])
except KeyError:
valuesChanges[k] = 'new Value: ' + str(objectInstance.changes['set'][k])
pass
print value + str(valuesChanges)
number += 1
if number == 0:
print " \033[91m<None>\033[0m"
print ""
print ' Groups need change:'
number = 0
for groupTemplate in LBEGroup.objects.all():
for groupInstance in self.backend.searchObjectsToUpdate(groupTemplate):
number += 1
type = ""
if groupInstance.changes['type'] == OBJECT_CHANGE_CREATE_OBJECT:
type += "\033[34mcreate"
elif groupInstance.changes['type'] == OBJECT_CHANGE_UPDATE_OBJECT:
type += "\033[36mupdate"
elif groupInstance.changes['type'] == OBJECT_CHANGE_DELETE_OBJECT:
type += "\033[33mdelete"
type += "\033[0m"
value = " " + type + ' \033[35m' + groupInstance.displayName + '\033[0m : '
valuesChanges = dict()
for k in groupInstance.changes['set']:
try:
if groupInstance.attributes[k] != groupInstance.changes['set'][k]:
valuesChanges[k] = 'new Value: ' + str(
groupInstance.changes['set'][k]) + ' | old value: ' + str(
groupInstance.attributes[k])
except KeyError:
valuesChanges[k] = 'new Value: ' + str(groupInstance.changes['set'][k])
pass
print value + str(valuesChanges)
if number == 0:
print " \033[91m<None>\033[0m"
"""
Show objects do not exist in LBE but LDAP.
"""
def _notExistObjectLBE(self):
print ' Checking for Objects which do not exist into LBE but in LDAP Server:'
for objectTemplate in LBEObjectTemplate.objects.all():
print " - \033[35m" + objectTemplate.name + '\033[0m...'
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
number = 0
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
exist = True
break
if not exist:
number += 1
print " " + ot.name
if number == 0:
print ' \033[91m<None>\033[0m'
print ""
print ' Checking for Groups which do not exist into LBE but in LDAP Server:'
number = 0
for groupTemplate in LBEGroup.objects.all():
grpHelper = GroupInstanceHelper(groupTemplate)
try:
scope = grpHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
grpTarget = self.target.searchObjects(groupTemplate, scope, '(cn=' + groupTemplate.displayName + ')')
grpBackend = self.backend.searchObjectsByPattern(groupTemplate, groupTemplate.displayName)
if not grpBackend:
print " - \033[36m" + groupTemplate.displayName + "\033[0m does not exists."
number += 1
if number == 0:
print ' \033[91m<None>\033[0m'
def start(self):
self._needModification()
print ""
print '\033[93m.........................\033[0m'
print '\033[93m.........................\033[0m'
print ""
self._notExistObjectLBE()
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
class UpgradeBT():
def __init__(self):
self.backend = BackendHelper()
self.target = TargetHelper()
self.start_date = django.utils.timezone.now()
def _deleteORCreate(self, objectTemplate, ot):
if objectTemplate.reconciliation_object_missing_policy == OBJECT_ADD_BACKEND:
print " |-> Adding \033[95m'" + ot.displayName + "'\033[0m object into Backend... "
try:
self.backend.createObject(objectTemplate, ot, True)
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, ot, changes)
except BaseException as e:
print "''''''''"
print e
print "''''''''"
elif objectTemplate.reconciliation_object_missing_policy == OBJECT_DELETE_TARGET:
print " |-> Removing \033[95m'" + ot.displayName + "'\033[0m object from Target... "
try:
self.target.delete(objectTemplate, ot)
except BaseException as e:
print "''''''''"
print e
print "''''''''"
def _upgradeObject(self, objectTemplate, objHelper, ot, ob):
# check and replace ignore attributes:
ignoreAttributes = objHelper.callScriptClassMethod("ignore_attributes")
for key, values in ot.attributes.items():
if key in ignoreAttributes:
ob.attributes[key] = ot.attributes[key]
if not ot.attributes == ob.attributes:
if objectTemplate.reconciliation_object_different_policy == TARGET:
# check if values are empty []:
# Then, skip it.
numberEmpty = 0
for values in set(ot.attributes) ^ set(ob.attributes):
try:
# either empty or empty string:
if ob.attributes[values] == [] or ob.attributes[
values] == ['']:
numberEmpty += 1
except BaseException:
pass
if not numberEmpty == 0 and numberEmpty == len(
set(ot.attributes) ^ set(ob.attributes)):
return
print " |-> Upgrade Object '\033[35m" + ob.displayName + "\033[0m' into Target..."
print " |-> -------------------------------------------- "
print " ||-> Old Values: " + str(ot.attributes)
print " ||-> New Values: " + str(ob.attributes)
print " |-> -------------------------------------------- "
# Remove & Add in order to add new attributes:
try:
# Remove:
self.target.delete(objectTemplate, ob)
# Add
self.target.create(objectTemplate, ob)
# Synced:
changes = {}
changes['status'] = OBJECT_STATE_SYNCED
changes['changes'] = {}
changes['changes']['set'] = {}
changes['changes']['type'] = -1
changes['synced_at'] = django.utils.timezone.now()
self.backend.updateObject(objectTemplate, ob, changes)
except BaseException as e:
print e
elif objectTemplate.reconciliation_object_different_policy == BACKEND:
print " |-> Upgrade Object '\033[35m" + ob.displayName + "\033[0m' into Backend..."
print " |-> -------------------------------------------- "
print " ||-> Old Values: " + str(ob.attributes)
print " ||-> New Values: " + str(ot.attributes)
print " |-> -------------------------------------------- "
try:
self.backend.updateObject(objectTemplate, ob, ot)
except BaseException as e:
print e
def start(self):
print " Upgrade Server..."
for objectTemplate in LBEObjectTemplate.objects.all():
print " |-> \033[91m" + objectTemplate.name + '\033[0m:'
objHelper = LBEObjectInstanceHelper(objectTemplate)
try:
scope = objHelper.callScriptClassMethod("search_scope")
except BaseException:
scope = 0
objTarget = self.target.searchObjects(objectTemplate, scope)
objBackend = self.backend.searchObjects(objectTemplate)
# Target to Backend:
for ot in objTarget:
exist = False
for ob in objBackend:
if ot.name == ob.name:
self._upgradeObject(objectTemplate, objHelper, ot, ob)
exist = True
break
if not exist:
self._deleteORCreate(objectTemplate, ot)
# Synced object:
objectTemplate.synced_at = django.utils.timezone.now()
objectTemplate.save()
print " End."
