/*
* Add child node to parent node.
*/
int registryAddChild(Registry registry,Node parent_,Node child_,char* arcName,int arcNameLength){
NodeInternal* parent=(NodeInternal*)parent_;
Arc oldArc;
stringHashmapGet(parent->children,arcName,arcNameLength,(Object*)&oldArc);
Arc arc=arcCreate(parent_,child_,arcName,arcNameLength);
stringHashmapPut(parent->children,arcName,arcNameLength,arc);
if(oldArc!=NULL){
arcFree(oldArc);
}
return VALID;
}
void fileHelperLoad(FileHelper fileHelper) {
FileHelperInternal *m = (FileHelperInternal *) fileHelper;
fileHelperCheckCreate(m->filePath);
int sizeOfInt = sizeof(int);
struct direct **schemasIds = {0};
struct direct *schenaId;
int size = scandir(m->filePath, &schemasIds, 0, alphasort);
// loop all schemas
int i;
for (i = 0; i < size; i++) {
schenaId = (struct direct *) schemasIds[i];
char *schemaIdString = schenaId->d_name;
int schemaId = atoi(schemaIdString);
if (schemaId != 0) {
printf("schema %s\n", schenaId->d_name);
struct direct **pagesIds = {0};
struct direct *pageStruct;
char endOdString = '\0';
int pageDirLength = strlen(m->filePath);
int schemaIdStringLength = strlen(schemaIdString);
char slesh = '/';
char *pageDir = (char *) memoryAlloc(pageDirLength + 1 + schemaIdStringLength + 1);
memcpy(pageDir, m->filePath, pageDirLength);
memcpy(pageDir + pageDirLength, &slesh, 1);
memcpy(pageDir + pageDirLength + 1, schemaIdString, schemaIdStringLength);
memcpy(pageDir + pageDirLength + 1 + schemaIdStringLength, &endOdString, 1);
// cleanBuffer(pageDir);
// strcat(pageDir,m->filePath);
// strcat(pageDir,"/");
// strcat(pageDir,schemaIdString);
HashMap childrenRelations = hashmapCreate(SMALL_CONTAINER_SIZE);
Registry registry = registryCreate();
hashmapPut(m->registryMap, schemaId, registry);
PageManager pageManager = pageManagerCreate(schemaId, pageDir);
hashmapPut(m->managers, schemaId, pageManager);
int size = scandir(pageDir, &pagesIds, 0, alphasort);
int h;
//loop pages
for (h = 0; h < size; h++) {
//scandir (pageDir, &pagesIds, 0, alphasort);
pageStruct = (struct direct *) pagesIds[h];
char *pageString = pageStruct->d_name;
int pageId = atoi(pageString);
if (pageId != 0) {
printf("page %s\n", pageStruct->d_name);
// create file path.
//int i=0;
int pageDirLength = strlen(pageDir);
int pageStringLength = strlen(pageString);
char slesh = '/';
char *filePath = (char *) memoryAlloc(pageDirLength + 1 + pageStringLength + 1);
memcpy(filePath, pageDir, pageDirLength);
memcpy(filePath + pageDirLength, &slesh, 1);
memcpy(filePath + pageDirLength + 1, pageString, pageStringLength);
memcpy(filePath + pageDirLength + 1 + pageStringLength, &endOdString, 1);
FILE *fp;
long len;
// Create pointer to file.
fp = fopen(filePath, "rb");
if (fp == NULL) {
printf("couldn't open the properties file");
}
fseek(fp, 0, SEEK_END); // Go to end
len = ftell(fp); // Get position at end (length)
// Read data to buffer
char *buffer = memoryAlloc(sizeof(char) * len); // Create buffer
char *pointerToFreeBuffer = buffer;
fseek(fp, 0, SEEK_SET); // Go to the beginning.
int result = fread(buffer, len, 1, fp); // Read into buffer
if (result < 0) {
printf("Fail to read file : %s", buffer);
}
fclose(fp);
int order = 0;
long index = 0;
long step = 0;
while (index < len) {
char *start = buffer;
int id;
int schemaId;
int numberOfAttributes;
int childrenSize;
int attributeSize;
memcpy(&schemaId, buffer + SIZE_OF_INT * 0, SIZE_OF_INT);
memcpy(&id, buffer + SIZE_OF_INT * 1, SIZE_OF_INT);
memcpy(&numberOfAttributes, buffer + SIZE_OF_INT * 2, SIZE_OF_INT);
buffer += SIZE_OF_INT * 3;
Node node;
nodeCreate(registry, id, schemaId, FALSE, &node);
int h;
for (h = 0; h < numberOfAttributes; h++) {
memcpy(&attributeSize, buffer, SIZE_OF_INT);
Attribute attribute = attributeDeserializeLocal(buffer);
buffer += attributeSize;
stringHashmapPut(node->attributes, attribute->name, attribute->nameLength, attribute);
}
memcpy(&childrenSize, buffer, SIZE_OF_INT);
Array children = arrayCreate(childrenSize);
hashmapPut(childrenRelations, id, children);
int i;
buffer += SIZE_OF_INT;
int childrenIdBuffer;
for (i = 0; i < childrenSize; i++) {
memcpy(&childrenIdBuffer, buffer + SIZE_OF_INT, SIZE_OF_INT);
void *bufferElement = memoryAlloc(childrenIdBuffer + SIZE_OF_INT * 2);
memcpy(bufferElement, buffer, SIZE_OF_INT * 2 + childrenIdBuffer);
arrayInsertObject(children, bufferElement);
buffer += SIZE_OF_INT * 2 + childrenIdBuffer;
}
step = buffer - start;
index += step;
pageManagerRegister(pageManager, pageId, id, index - step, index, order, filePath);
order++;
}
// Free the file buffer
memoryFree(pointerToFreeBuffer);
}
}
if (size > 0) {
while (size) {
size = size - 1;
free(pagesIds[size]);
}
free(pagesIds);
}
hashmapIterate(childrenRelations, &updateChildren, registry);
hashmapFree(childrenRelations);
}
}
if (size > 0) {
while (size) {
size = size - 1;
free(schemasIds[size]);
}
free(schemasIds);
}
}
int validationManagerValidateOnCoreExecuteInternalRecurcive(ValidationManager validationManager,ArrayList commands,int administrator,int dept){
ValidationManagerStruct* internal=(ValidationManagerStruct*)validationManager;
if(commands!=NULL&&dept<arrayListSize(commands)){
Command command=arrayListGetValueAt(commands,dept);
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
int sessionId=commandGetInt(command,SESSION_ID);
int transaction=commandGetInt(command,TRANSACTION);
int schimaId=commandGetInt(command,SCHEMA_ID);
int type=commandGetInt(command,COMMAND_TYPE);
int version=commandGetInt(command,VERSION);
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_TRANSACTION(transaction);
VALIDATE_CORE_MANAGER_ID(coreManagerId);
VALIDATE_SESSION_ID(sessionId);
if(IS_CREATE_NEW_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
VALIDATE(registryValidateNodeCreate(internal->registry,entityId));
Node node;
nodeCreate(internal->registry,entityId,schimaId,lock,&node);
stringHashmapPutAll(node->attributes,newAttributesMap);
stringHashmapFree(newAttributesMap);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryDeleteNode(internal->registry,node);
return result;
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_ADD_CHILD_ENTITY_TO_PARENT_ENTITY(type)){
char* arcName;
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
int arcNameLenght=commandGetString(command,ARC_NAME,&arcName);
Node parent;
registryGetNode(internal->registry,entityId,&parent);
Node child;
registryGetNode(internal->registry,childEntityId,&child);
VALIDATE(registryValidateAddChild(parent,child,arcName,arcNameLenght,sessionId));
registryAddChild(internal->registry,parent,child,arcName,arcNameLenght);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryRemoveChild(internal->registry,parent,arcName,arcNameLenght);
return result;
}
char* buf;
int length=nodeSerialize(parent,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY(type)){
char* arcName;
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
int arcNameLenght=commandGetString(command,ARC_NAME,&arcName);
Node parent;
registryGetNode(internal->registry,entityId,&parent);
Node child;
registryGetNode(internal->registry,childEntityId,&child);
VALIDATE(registryValidateRemoveChild(parent,arcName,arcNameLenght,sessionId));
registryRemoveChild(internal->registry,parent,arcName,arcNameLenght);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryAddChild(internal->registry,parent,child,arcName,arcNameLenght);
return result;
}
char* buf;
int length=nodeSerialize(parent,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_LOCK_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
int forceLock=commandGetInt(command,FORCE_LOCK);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdateLock(node,lock,sessionId,forceLock,administrator));
registryUpdateLock(internal->registry,node,lock,sessionId);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
int revertedLock=lock==TRUE?FALSE:TRUE;
registryUpdateLock(internal->registry,node,revertedLock,sessionId);
return result;
}
}
if(IS_DELETE_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
Node node;
VALIDATE(registryGetNode(internal->registry,entityId,&node));
VALIDATE(registryValidateDeleteNode(node,sessionId));
registryDeleteNode(internal->registry,node);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
nodeCreate(internal->registry,entityId,schimaId,lock,&node);
return result;
}
}
if(IS_ADD_ATTRIBUTE(type)){
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdate(node,sessionId));
Array array;
stringHashmapToArray(newAttributesMap,&array);
int lenght=arrayGetLength(array);
int i;
StringHashMap toRemove = stringHashmapCreate(SMALL_CONTAINER_SIZE);
for(i=0;i<lenght;i++){
Attribute newAttribute=(Attribute)arrayGetObject(array,i);
Attribute oldAttribute;
stringHashmapGet(node->attributes,newAttribute->name,newAttribute->nameLength,(Object) &oldAttribute);
if(oldAttribute!=NULL){
stringHashmapPut(toRemove,newAttribute->name,newAttribute->nameLength,oldAttribute);
stringHashmapRemove(node->attributes,newAttribute->name,newAttribute->nameLength);
}
stringHashmapPut(node->attributes,newAttribute->name,newAttribute->nameLength,(Object)newAttribute);
}
arrayFree(array);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(newAttributesMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute newAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,newAttribute->name,newAttribute->nameLength);
attributeFree(newAttribute,TRUE);
}
stringHashmapPutAll(node->attributes,toRemove);
arrayFree(array);
stringHashmapFree(toRemove);
}else{
stringHashmapToArray(toRemove,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(toRemove,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemove);
}
stringHashmapFree(newAttributesMap);
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_REMOVE_ATTRIBUTE(type)){
StringHashMap toRemoveAttributeMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdate(node,sessionId));
Array array;
stringHashmapToArray(toRemoveAttributeMap,&array);
int lenght=arrayGetLength(array);
int i;
StringHashMap oldAttributes = stringHashmapCreate(SMALL_CONTAINER_SIZE);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
Attribute oldAttribute;
stringHashmapGet(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object) &oldAttribute);
if(oldAttribute!=NULL){
stringHashmapPut(oldAttributes,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object)oldAttribute);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
}
}
arrayFree(array);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(oldAttributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(node->attributes,oldAttribute->name,oldAttribute->nameLength,(Object)oldAttribute);
}
arrayFree(array);
stringHashmapToArray(toRemoveAttributeMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(toRemoveAttributeMap,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object)toRemoveAttribute);
attributeFree(toRemoveAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemoveAttributeMap);
}else{
stringHashmapToArray(oldAttributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(oldAttributes,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
arrayFree(array);
stringHashmapToArray(toRemoveAttributeMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toAddAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(toRemoveAttributeMap,toAddAttribute->name,toAddAttribute->nameLength,(Object)toAddAttribute);
attributeFree(toAddAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemoveAttributeMap);
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_UPDATE_ENTITY(type)){
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
StringHashMap oldAttributesMap=stringHashmapCreate(SMALL_CONTAINER_SIZE);
stringHashmapPutAll(oldAttributesMap,node->attributes);
Array array;
stringHashmapToArray(node->attributes,&array);
int lenght=arrayGetLength(array);
int i;
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
}
stringHashmapPutAll(node->attributes,newAttributesMap);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(node->attributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
attributeFree(toRemoveAttribute,TRUE);
}
stringHashmapPutAll(node->attributes,oldAttributesMap);
stringHashmapFree(newAttributesMap);
stringHashmapFree(oldAttributesMap);
}else{
stringHashmapToArray(oldAttributesMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(oldAttributesMap,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
stringHashmapFree(oldAttributesMap);
stringHashmapFree(newAttributesMap);
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
}
return VALID;
}
