Beispiel #1
0
        /**
         * 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);
                    }
                }
            }
        }
Beispiel #2
0
 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);
     }
 }
Beispiel #3
0
        /**
         * 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());
        }