/**
* 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());
}
