int commandExecuterDeleteEntity(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node node;
int result;
result=registryGetNode(internal->registry,commandGetInt(command,ENTITY_ID),&node);
VALIDATE(result);
return registryDeleteNode(internal->registry,node,commandGetInt(command,SESSION_ID));
}
int commandExecuterRemoveChild(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node parent;
int result;
result=registryGetNode(internal->registry,commandGetInt(command,ENTITY_ID),&parent);
VALIDATE(result);
Node child;
char* arcName;
int arcLength=commandGetByteArray(command,ARC_NAME,&arcName);
return registryRemoveChild(internal->registry,parent,arcName,arcLength,commandGetInt(command,SESSION_ID));
}
int commandExecuterNewEntity(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node node;
StringHashMap attributesMap=commandGetAttributes(command,ATTRIBUTES);
int lock=commandGetInt(command,LOCK)==TRUE?TRUE:FALSE;
int result= nodeCreate(internal->registry,commandGetInt(command,ENTITY_ID),commandGetInt(command,SCHEMA_ID),lock,&node,internal->sessionMetaData->id);
if(result==VALID){
stringHashmapPutAll(node->attributes,attributesMap);
}
stringHashmapFree(attributesMap);
return result;
}
int commandExecuterRemoveAttribute(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node node;
int result;
result=registryGetNode(internal->registry,commandGetInt(command,ENTITY_ID),&node);
VALIDATE(result);
StringHashMap attributesMap=commandGetAttributes(command,ATTRIBUTES);
int sessionId=commandGetInt(command,SESSION_ID);
result= registryRemoveAttributes(internal->registry,node,attributesMap,sessionId);
stringHashmapFree(attributesMap);
return result;
}
int commandExecuterLockEntity(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node node;
int result;
int force=commandGetInt(command,FORCE_LOCK);
result=registryGetNode(internal->registry,commandGetInt(command,ENTITY_ID),&node);
VALIDATE(result);
int sessionId=commandGetInt(command,SESSION_ID);
int lock=commandGetInt(command,LOCK);
if(force<0 || force>1){
force=FALSE;
}
return registryUpdateLock(internal->registry,node,lock,sessionId,force);
}
void commandContainerCleanup(CommandContainer commandContainer){
CommandContainerInternal* internal=(CommandContainerInternal*)commandContainer;
lockLock(internal->lock);
time_t currentTime; // Stores seconds elapsed since 01-01-1970
time(¤tTime);
// Cleanup atomic commands
if(linkedListSize(internal->atomicCommands)>0){
int length=linkedListSize(internal->atomicCommands);
Command atomicCommand;
while(length>0){
linkedListGetFirst(internal->atomicCommands,(Object*)&atomicCommand);
int commandTime=commandGetInt(atomicCommand,SERVER_HANDLING_TIME);
int distributed=commandGetInt(atomicCommand,DISTRIBUTED);
if((currentTime-commandTime>MAX_TIME_TO_HOLD_COMMAND&&distributed==TRUE)||(currentTime-commandTime>MAX_TIME_TO_HOLD_UNCLEANED_COMMAND)){
commandFree(atomicCommand);
linkedListRemoveFirst(internal->atomicCommands);
}else{
break;
}
length=linkedListSize(internal->atomicCommands);
}
}
// Cleanup commands
int length=linkedListSize(internal->versions);
int i;
int* intBuffer;
while(length>0){
linkedListGetFirst(internal->versions,(Object*)&intBuffer);
Command temp;
hashmapGet(internal->versionMap,*intBuffer,(Object*)&temp);
int commandTime=commandGetInt(temp,SERVER_HANDLING_TIME);
int persisted=commandGetInt(temp,PERSISTED);
int distributed=commandGetInt(temp,DISTRIBUTED);
if((currentTime-commandTime>MAX_TIME_TO_HOLD_COMMAND&&persisted==TRUE&&distributed==TRUE)||(currentTime-commandTime>MAX_TIME_TO_HOLD_UNCLEANED_COMMAND)){
linkedListRemoveFirst(internal->versions);
hashmapRemove(internal->versionMap,*intBuffer);
memoryFree(intBuffer);
commandFree(temp);
}else{
break;
}
length=linkedListSize(internal->versions);
}
lockUnlock(internal->lock);
}
int validationManagerValidateOnCoreEntry(ValidationManager validationManager,Command command,ArrayList commands){
int type=commandGetInt(command,COMMAND_TYPE);
int administrator=commandGetInt(command,MARKED_AS_ADMINISTRATOR);
if(IS_ATOMIC_MODEL_COMMAND(type)){
int commandsLength=arrayListSize(commands);
int i;
for(i=0;i<commandsLength;i++){
Command tempCpmmand=arrayListGetValueAt(commands,i);
type=commandGetInt(tempCpmmand,COMMAND_TYPE);
int result=validationManagerValidateOnCoreEntryInternal(validationManager,tempCpmmand,type,administrator);
if(result!=VALID){
return result;
}
}
return VALID;
}else{
return validationManagerValidateOnCoreEntryInternal(validationManager,command,type,administrator);
}
}
int validationManagerValidateOnCoreExecute(ValidationManager validationManager,Command command,ArrayList commands,int atomic){
int administrator=commandGetInt(command,MARKED_AS_ADMINISTRATOR);
if(atomic==TRUE){
return validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,0);
}else{
commands =arrayListCreate();
arrayListAddLast(commands,command);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,0);
arrayListFree(commands);
return result;
}
}
int commandExecutorProduce(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal * internal=(CommandExecuterInternal*)commandExecuter;
int type=commandGetInt(command,COMMAND_TYPE);
if(IS_MODEL_COMMAND(type)==TRUE){
//noinspection SynchronizationOnLocalVariableOrMethodParameter
Lock lock=lockCreate();
lockLock(lock);
coreConsume(internal->core,command);
int status = commandGetInt(command,COMMAND_STATUS);
if( status=VALID){
return status;
}
environmentWaitObject(command,lock);
}else{
coreConsume(internal->core,command);
int status = commandGetInt(command,COMMAND_STATUS);
if( status=VALID){
return status;
}
}
return VALID;
}
void commandContainerPushCommand(CommandContainer commandContainer,Command command){
CommandContainerInternal* internal=(CommandContainerInternal*)commandContainer;
lockLock(internal->lock);
time_t currentTime; // Stores seconds elapsed since 01-01-1970
time(¤tTime);
int type=commandGetInt(command,COMMAND_TYPE);
if(type==ATOMIC_MODEL_COMMAND){
commandPush(command,SERVER_HANDLING_TIME,INTEGER,¤tTime);
linkedListAddLast(internal->atomicCommands,command);
}else{
int version=commandGetInt(command,VERSION);
int* intBuffer=memoryAlloc(SIZE_OF_INT);
memcpy(intBuffer,&version,SIZE_OF_INT);
commandPush(command,SERVER_HANDLING_TIME,INTEGER,¤tTime);
// Update version Map;
hashmapPut(internal->versionMap,version,command);
// Update version list
linkedListAddLast(internal->versions,intBuffer);
}
lockUnlock(internal->lock);
}
int commandExecuterConsume(CommandExecuter commandExecuter,Command command){
int type=commandGetInt(command,COMMAND_TYPE);
switch(type){
case CREATE_NEW_ENTITY:return commandExecuterNewEntity(commandExecuter,command);
case DELETE_ENTITY:return commandExecuterDeleteEntity(commandExecuter,command);
case ADD_CHILD_ENTITY_TO_PARENT_ENTITY:return commandExecuterAddChild(commandExecuter,command);
case REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY:return commandExecuterRemoveChild(commandExecuter,command);
case UPDATE_ENTITY:return commandExecuterUpdateEntity(commandExecuter,command);
case ADD_ATTRIBUTE:return commandExecuterAddAttribute(commandExecuter,command);
case REMOVE_ATTRIBUTE:return commandExecuterRemoveAttribute(commandExecuter,command);
case LOCK_ENTITY:return commandExecuterLockEntity(commandExecuter,command);
default: return UNSUPPORTED_MODEL_COMMAND;
}
}
TcpConnection tcpConnectionCreate(ConnectionPool connectionPool,DistributionManager distributionManager,int coreManagerId,Properties properties){
TcpConnectionInternal* m=(TcpConnectionInternal*)memoryAlloc(sizeof(TcpConnectionInternal));
m->connectionPool=connectionPool;
char* remoteIp=propertiesGet(properties,"ip");
int remotePort=atoi(propertiesGet(properties,"port"));
memset(&m->address, 0, sizeof(m->address)); /* Zero out structure */
m->address.sin_family = AF_INET; /* Internet address family */
m->address.sin_addr.s_addr = inet_addr(remoteIp); /* Server IP address */
m->address.sin_port = htons(remotePort); /* Server port */
/* Establish the connection to the echo server */
if((m->sockfd=socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
printf("Fail to establish tcp connection with the server - IP%s port %i ",remoteIp,remotePort);
return NULL;
}
if (connect(m->sockfd, (struct sockaddr *) &m->address, sizeof(m->address)) < 0){
printf("Fail to establish tcp connection with the server - IP%s port %i ",remoteIp,remotePort);
return NULL;
}
m->coreManagerId=coreManagerId;
m->remoteIp=strdup(remoteIp);
m->remoteIpLenght=strlen(remoteIp);
m->remotePort=remotePort;
m->distributionManager=distributionManager;
m->active=TRUE;
int set = 1;
setsockopt(m->sockfd, SOL_SOCKET, MSG_NOSIGNAL, (void *)&set, sizeof(int));
char* userName=propertiesGet(properties,"userName");
char* password=propertiesGet(properties,"password");
char* ip=propertiesGet(properties,"ip");
int port=atoi(propertiesGet(properties,"port"));
int userNameLenght=strlen(userName);
int passwordLenght=strlen(password);
int ipLenght=strlen(ip);
Command command= commandBuilderBuildTcpConnectionCommand(userName, userNameLenght,password,passwordLenght,coreManagerId,ip,ipLenght,port);
tcpConnectionSend(m,command);
int status = commandGetInt(command,COMMAND_STATUS);
if( status!=VALID){
printf("Fail to establish tcp connection with the server : cause is authentication failure.");
return NULL;
}
return m;
}
/*
* handleMessage
* 1. Create new TcpConnection or UdpConnection (depends on the request)
* 2. Register the new connection in the DistributionManager
*/
void handleMessage(int client_sockfd,ConnectionListenerInternal* connectionListenerInternal,Command command,char* ip) {
DistributionManager distributionManager=connectionListenerInternal->distributionManager;
distributionManagerConsumeTcp(distributionManager,command);
int status=commandGetInt(command,COMMAND_STATUS);
if(status==VALID) {
int type=commandGetInt(command,COMMAND_TYPE);
if(IS_TCP_CONNECTION(type)) {
// Create Tcp connection
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
TcpConnection connection=tcpConnectionCreate(distributionManager,client_sockfd,coreManagerId,ip,commandGetInt(command,PORT));
distributionManagerRegisterTcp(distributionManager,connection,coreManagerId);
tcpConnectionStartListener(connection);
}
if(IS_BROADCAST_TCP_CONNECTION(type)) {
// Create Tcp connection
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
TcpConnection connection=tcpConnectionCreate(distributionManager,client_sockfd,coreManagerId,ip,commandGetInt(command,PORT));
distributionManagerRegisterBroadcastTcp(distributionManager,connection,coreManagerId);
tcpConnectionStartWriter(connection);
}
if(IS_UDP_CONNECTION(type)) {
// Create Udp connection
char* interface=propertiesGet(connectionListenerInternal->properties,"interface");
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
int isRegistred=distributionManagerIsRegistred(distributionManager,coreManagerId);
if(isRegistred==FALSE) {
UdpConnection connection=udpConnectionCreate(distributionManager,coreManagerId,ip,commandGetInt(command,PORT),interface);
distributionManagerRegisterUdp(distributionManager,connection,coreManagerId);
udpConnectionSatrt(connection);
}
}
if(IS_MULTICAST_CONNECTION(type)) {
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
distributionManagerRegisterMulticast(distributionManager,NULL,coreManagerId);
}
int coreManagerId=distributionManagerGetCoreManager(distributionManager);
int status=VALID;
commandPush(command,CORE_MANAGER_ID,INTEGER,&coreManagerId);
commandPush(command,COMMAND_STATUS,INTEGER,&status);
}
}
void fileHelperConsume(FileHelper fileHelper, Command command) {
FileHelperInternal *m = (FileHelperInternal *) fileHelper;
PageManager pageManager = NULL;
int schemaId = commandGetInt(command, SCHEMA_ID);
int entityId = commandGetInt(command, ENTITY_ID);
hashmapGet(m->managers, schemaId, &pageManager);
char schemaIdString[10];
if (pageManager == NULL) {
stringConvertInt(schemaIdString, schemaId);
char *pageDir = (char *) memoryAlloc(strlen(m->filePath) + strlen(schemaIdString) + 1);
strcpy(pageDir, m->filePath);
strcat(pageDir, "/");
strcat(pageDir, schemaIdString);
mkdir(pageDir, S_IRWXU | S_IRGRP | S_IXGRP);
pageManager = pageManagerCreate(schemaId, pageDir);
hashmapPut(m->managers, schemaId, pageManager);
}
Registry registry;
hashmapGet(m->registryMap, schemaId, ®istry);
if (registry == NULL) {
Throw(Fatal, 1, "FileHelper unsupported state failed to find registry for schemaId ");
}
char *buf = NULL;
int type = commandGetInt(command, COMMAND_TYPE);
switch (type) {
case CREATE_NEW_ENTITY: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerAdd(pageManager, entityId, buf, lenght);
return;
}
case DELETE_ENTITY: {
pageManagerDelete(pageManager, entityId);
return;
}
case ADD_CHILD_ENTITY_TO_PARENT_ENTITY: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerUpdate(pageManager, entityId, buf, lenght);
return;
}
case REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerUpdate(pageManager, entityId, buf, lenght);
return;
}
case UPDATE_ENTITY: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerUpdate(pageManager, entityId, buf, lenght);
return;
}
case ADD_ATTRIBUTE: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerUpdate(pageManager, entityId, buf, lenght);
return;
}
case REMOVE_ATTRIBUTE: {
int lenght = commandGetByteArray(command, SERIALIZED_NODE, &buf);
pageManagerUpdate(pageManager, entityId, buf, lenght);
return;
}
}
}
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;
}
int validationManagerValidateOnCoreEntryInternal(ValidationManager validationManager,Command command,int type,int administrator){
ValidationManagerStruct* internal=(ValidationManagerStruct*)validationManager;
// Ensure that the command contains coreManagerId;
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
int sessionId=commandGetInt(command,SESSION_ID);
int transaction=commandGetInt(command,TRANSACTION);
int forceLock=commandGetInt(command,FORCE_LOCK);
VALIDATE_TRANSACTION(transaction);
VALIDATE_CORE_MANAGER_ID(coreManagerId);
VALIDATE_SESSION_ID(sessionId);
if(IS_CREATE_NEW_ENTITY(type)){
void* buffer;
int dataSize=0;//commandGetByteArray(command,ENTITY_DATA,&buffer);
int nameSize=0;//commandGetString(command,ENTITY_NAME,&buffer);
VALIDATE_DATA_SIZE(dataSize);
VALIDATE_NAME_SIZE(dataSize);
}
if(IS_UPDATE_ENTITY(type)||IS_ADD_ATTRIBUTE(type)||IS_REMOVE_ATTRIBUTE(type)){
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_ENTITY_ID(entityId,transaction);
int dataSize=0;//commandGetByteArray(command,ENTITY_DATA,&buffer);
int nameSize=0;//commandGetString(command,ENTITY_NAME,&buffer);
VALIDATE_DATA_SIZE(dataSize);
VALIDATE_NAME_SIZE(dataSize);
BASIC_VALIDATE(validationManagerIsLocked(validationManager,entityId,sessionId,administrator,forceLock));
}
if(IS_ADD_CHILD_ENTITY_TO_PARENT_ENTITY(type)){
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_ENTITY_ID(entityId,transaction);
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
VALIDATE_CHILD_ENTITY_ID(childEntityId,transaction);
BASIC_VALIDATE(validationManagerIsLocked(validationManager,entityId,sessionId,administrator,forceLock));
BASIC_VALIDATE(validationManagerIsLocked(validationManager,childEntityId,sessionId,administrator,forceLock));
}
if(IS_REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY(type)){
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_ENTITY_ID(entityId,transaction);
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
VALIDATE_CHILD_ENTITY_ID(childEntityId,transaction);
BASIC_VALIDATE(validationManagerIsLocked(validationManager,entityId,sessionId,administrator,forceLock));
BASIC_VALIDATE(validationManagerIsLocked(validationManager,childEntityId,sessionId,administrator,forceLock));
}
if(IS_LOCK_ENTITY(type)){
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_ENTITY_ID(entityId,transaction);
int lock=commandGetInt(command,LOCK);
VALIDATE_LOCK_VALUE(lock);
int force=commandGetInt(command,FORCE_LOCK);
VALIDATE_FORCE(force,administrator);
BASIC_VALIDATE(validationManagerIsLocked(validationManager,entityId,sessionId,administrator,forceLock));
}
return VALID;
}
