/**
* this is the heart of the storage,<p>
* It control all the in coming commands.<p>
* The method does the following<p>
* 1. validate the command<p>
* 2. update the version number and the conflict number (if needed)<p>
* 3. push the command to the command queue<p>
*/
public void consume(Command command)
{
// update schema and coreManagerKey in command in case that the schema or coreManagerKey fields in the command are null
if(command.GetSchemaId()<0){
command.setSchemaId(getSessionMetaData().getSchemaId());
}
if(command.GetCoreManagerKey()==null){
command.setCoreManagerKey(getCoreManager().getKey());
}
// you do not have to handle your messages which NetworkProtocolType is multicast
// because you have already handle them
NetworkProtocolType type = command.getNetworkProtocolType();
if(type!=null && isCast(type) && command.GetCoreManagerKey().Equals(getCoreManager().getKey())&&sessionMetaData.GetSessionId()==command.GetSessionId()){
return;
}
//TODO validate message
if(command.isModeCommand()||command.isAtomicModelCommand()){ // model change commands
// set version number or distribute
if(command.getVersion()<0){
distributionManager.produceTcp(command);
int version = command.getVersion();
// return if command is lock or something was wrong
if(version<0|| command.isNotSucceed()){
return;
}
}
if(command.isAtomicModelCommand()){
List<Command> commands = command.getCommands();
atomicContainer.register(command,commands);
foreach (Command newCommand in commands) {
commandQueue.pushCommand(newCommand);
}
}else{
commandQueue.pushCommand(command);
}
}else{
Int32 commandType = command.getCommandType();
if(commandType==PlanckDBConstants.READ_LOCK_COMMAND){
if( ! command.GetCoreManagerKey().Equals(coreManager.getKey())){
List<Command> commands=command.getCommands();
bool entityLock=command.isLocked();
foreach (Command newCommand in commands) {
int entityId=newCommand.getEntityId();
int ownerId=newCommand.getOwnerId();
if(entityLock){
registry.lockEntity(entityId,true,ownerId);
}else{
registry.lockEntity(entityId,false,PlanckDBConstants.NON_ENTITY_OWNER);
}
}
}else{
distributionManager.produceTcp(command);
}
}
}
}
public void pushCommand(Command command)
{
lock (this){
int version = command.getVersion();
if(commandQueue.get(version)==null&&version>=currentVersion){
if(mode.Equals(Mode.normal)){
commandQueue.insertMessage(version,command);
}else if(mode.Equals(Mode.locking)){
int? lastVersion = commandQueue.getLastVersion();
if(version<lastVersion){
commandQueue.insertMessage(version,command);
}else {
tempCommandQueue.insertMessage(version,command);
}
}else{
tempCommandQueue.insertMessage(version,command);
}
}
System.Threading.Monitor.Pulse(this);
}
}
/**
* 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());
}
