/** * consume * Discriminate the command handler * Called by the core. * @param command * @throws PlanckDBException */ public void consume(Command command) { Int32 type=command.getCommandType(); switch (type){ case PlanckDBConstants.CREATE_NEW_ENTITY:handleNewItemCommand( command);break; case PlanckDBConstants.DELETE_ENTITY:handleRemoveItemCommand(command);break; case PlanckDBConstants.ADD_CHILD_ENTITY_TO_PARENT_ENTITY: handleAddChildToParent(command);break; case PlanckDBConstants.REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY:handleRemoveChildFromParent(command);break; case PlanckDBConstants.UPDATE_ENTITY: handleUpdateNodeCommand(command);break; case PlanckDBConstants.LOCK_ENTITY:handleLockItemCommand(command);break; case PlanckDBConstants.ADD_ATTRIBUTE:handleAddAttributeCommand(command);break; case PlanckDBConstants.REMOVE_ATTRIBUTE:handleRemoveAttributeCommand(command);break; } int entityId=command.getEntityId(); int? commandSchemaId=command.GetSchemaId(); foreach (Transaction transaction in transactions) { if(commandSchemaId!=transaction.schemaId()){ transaction.getDirtySet().Add(entityId); } } }
/** * handleAddAttributeCommand * Adds or override new attributes to * @param addAttributeCommand */ public void handleAddAttributeCommand(Command addAttributeCommand) { int entityId=addAttributeCommand.getEntityId(); NodeAttribute[] attributes = addAttributeCommand.getAttributes(); registry.addAttributes(entityId, attributes); Node node=registry.getNode(entityId); foreach (NodeAttribute attribute in attributes) { NodeAttribute oldValue = node.getAttributes().get(attribute.getName()); if(oldValue!=null){ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.attributeChanged(node, oldValue, attribute); } }else{ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.attributeAdded(node, attribute); } } } }
/** * handleUpdateNodeCommand * Remove old attributes and set or override new ones. * @param updateItemCommand */ public void handleUpdateNodeCommand(Command updateItemCommand) { int entityId=updateItemCommand.getEntityId(); NodeAttribute[] attributes = updateItemCommand.getAttributes(); Node node=registry.getNode(entityId); List<NodeAttribute> removedAttributes = registry.updateNode(entityId, attributes); foreach (NodeAttribute oldAttribute in removedAttributes) { foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.attributeChanged(node, oldAttribute, null); } } foreach (NodeAttribute attribute in attributes) { NodeAttribute oldValue = node.getAttributes().get(attribute.getName()); if(oldValue!=null){ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.attributeChanged(node, oldValue, attribute); } }else{ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.attributeAdded(node, attribute); } } } }
/** * handleLockItemCommand * Locks node * @param lockCommand */ private void handleLockItemCommand(Command lockCommand) { int entityId=lockCommand.getEntityId(); bool entityLock=lockCommand.getLock(); int ownerId=entityLock?lockCommand.GetSessionId():PlanckDBConstants.NON_ENTITY_OWNER; Node node = registry.getNode(entityId); registry.lockNode(entityId,entityLock,ownerId); foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.lockChanged(node,entityLock); } }
/** * handleRemoveChildFromParent * Removes child node from parent node * @param removeItemFromCollectionCommand */ public void handleRemoveChildFromParent(Command removeItemFromCollectionCommand) { int parentId=removeItemFromCollectionCommand.getEntityId(); byte[] arcName = removeItemFromCollectionCommand.getArcName(); Arc arc = registry.removeChildFromParent(parentId, arcName); foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.arcRemoved(arc); } }
/** * handleRemoveItemCommand * Remove node from memory * NOTE : after removing node, the node will become phantom * @param removeItemCommand */ public void handleRemoveItemCommand(Command removeItemCommand) { int entityId=removeItemCommand.getEntityId(); Node node=registry.getNode(entityId); registry.remove(entityId); foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.removeItem(node); } }
/** * handleRemoveAttributeCommand * Removes attributes from node * @param updateItemCommand */ public void handleRemoveAttributeCommand(Command updateItemCommand) { int entityId=updateItemCommand.getEntityId(); NodeAttribute[] attributes = updateItemCommand.getAttributes(); registry.removeAttributes(entityId, attributes); Node node=registry.getNode(entityId); foreach (NodeModelChangedListener listenerNode in listenerNodes) { foreach (NodeAttribute attribute in attributes) { listenerNode.attributeChanged(node, attribute, null); } } }
/** * handleNewItemCommand * Creates new node * @param itemCommand * @throws PlanckDBException */ public void handleNewItemCommand(Command itemCommand) { int entityId= itemCommand.getEntityId(); NodeAttribute[] attributes = itemCommand.getAttributes(); bool entityLock= itemCommand.getLock(); int ownerId=entityLock? itemCommand.GetSessionId(): PlanckDBConstants.NON_ENTITY_OWNER; registry.createNewNode(entityId,entityLock,sessionMetaData.GetSessionId(),ownerId,attributes); Node node=registry.getNode(entityId); foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.newItem(node); } foreach (NodeModelChangedListener listenerNode in listenerNodes) { foreach (NodeAttribute attribute in attributes) { listenerNode.attributeChanged(node, null, attribute); } } }
/** * handleAddChildToParent * Adds child node to parent node * @param addItemToCollectionCommand */ public void handleAddChildToParent(Command addItemToCollectionCommand) { int parentId=addItemToCollectionCommand.getEntityId(); int childId=addItemToCollectionCommand.getChildEntityId(); byte[] arcName=addItemToCollectionCommand.getArcName(); Node parent=registry.getNode(parentId); Arc oldArc = parent.getChildArc(arcName); Arc arc =registry.addChildToParent(parentId, childId,arcName); if(oldArc!=null){ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.arcChanged(oldArc, arc); } }else{ foreach (NodeModelChangedListener listenerNode in listenerNodes) { listenerNode.arcAdded(arc); } } }
public Command revertCommand(Command command) { int commandType=command.getCommandType(); Int32 entityId = command.getEntityId(); Int32 childEntityId = command.getChildEntityId(); Int32 schemaId=(Int32)command.GetSchemaId(); Int32 coreManagerId=command.GetCoreManagerKey(); Int32 sessionId=command.GetSessionId(); bool lockEntity=command.getLock(); bool oldLock=command.getOldLock(); NodeAttribute[] oldAttributes=command.getOldAttributes(); NodeAttribute[] attributes=command.getAttributes(); byte[] arcName=command.getArcName(); long lockTimeout=command.getLockTimeOut(); switch (commandType){ case PlanckDBConstants.CREATE_NEW_ENTITY:{ return buildDeleteNode(entityId,lockEntity,schemaId,coreManagerId,sessionId, lockTimeout, attributes); } case PlanckDBConstants.DELETE_ENTITY:{ Command newCommand= buildCreateNode(oldLock,schemaId,coreManagerId,sessionId, lockTimeout, oldAttributes); newCommand.Push(PlanckDBConstants.ENTITY_ID, PlanckDBConstants.INTEGER,entityId); return newCommand; } case PlanckDBConstants.ADD_CHILD_ENTITY_TO_PARENT_ENTITY:{ return buildRemoveChildFromParentNode(entityId,arcName,childEntityId,schemaId,coreManagerId,sessionId, lockTimeout); } case PlanckDBConstants.REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY:{ return buildAddChildToParentNode(entityId,childEntityId,arcName,schemaId,coreManagerId,sessionId, lockTimeout); } case PlanckDBConstants.UPDATE_ENTITY:{ Command newCommand = buildUpdateNode(entityId, schemaId, coreManagerId, sessionId, lockTimeout, attributes); newCommand.Push(PlanckDBConstants.OLD_ATTRIBUTES, PlanckDBConstants.ATTRIBUTE_MAP,oldAttributes); return newCommand; } case PlanckDBConstants.ADD_ATTRIBUTE:{ return buildRemoveAttributes(entityId,schemaId,coreManagerId,sessionId,lockTimeout,attributes); } case PlanckDBConstants.REMOVE_ATTRIBUTE:{ return buildAddAttributes(entityId,schemaId,coreManagerId,sessionId, lockTimeout, oldAttributes); } } throw new PlanckDBException("unsupported state the should not reach to this point of the code"); }
/** * The method does the following:<p> * 1.in case of none atomic command<p> * - execute the command using the command executor<p> * - notify all waiting thread about the command execution<p> * 2.in case of atomic command<p> * - execute the command using the command executor<p> * - notify all waiting thread about the command execution only<p> * if the current command is the last element in the atomic command * * @param modelCommand * @throws PlanckDBException */ public void doJobs(Command modelCommand) { bool consume=true; if( modelCommand.getTransaction()==PlanckDBConstants.TRUE && modelCommand.GetSessionId()==sessionMetaData.GetSessionId()){ consume=false; } if(consume){ commandExecutor.consume(modelCommand); } if(atomicContainer.isPartOfAtomicCommand(modelCommand)){ Command rootCommand = atomicContainer.update(modelCommand); if(rootCommand!=null){ lock(rootCommand){ Monitor.PulseAll(rootCommand); } } }else{ lock(modelCommand){ Monitor.PulseAll(modelCommand); } } log.info("message done version : "+modelCommand.getVersion()+" id "+modelCommand.getEntityId()); }