Examples with CompoundCommand org.alfresco.filesys.repo.rules.commands.CompoundCommand used on opensource projects

Example 11 with CompoundCommand

use of org.alfresco.filesys.repo.rules.commands.CompoundCommand in project alfresco-repository by Alfresco.

the class ScenarioDeleteRestoreInstance method evaluate.

/**
 * Evaluate the next operation
 * @param operation Operation
 */
public Command evaluate(Operation operation) {
    /**
     * Anti-pattern : timeout
     */
    Date now = new Date();
    if (now.getTime() > startTime.getTime() + getTimeout()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Instance timed out deleteName:" + deleteName);
            isComplete = true;
            return null;
        }
    }
    switch(internalState) {
        case NONE:
            /**
             * Looking for file being deleted deleted
             */
            if (operation instanceof DeleteFileOperation) {
                DeleteFileOperation d = (DeleteFileOperation) operation;
                deleteName = d.getName();
                if (logger.isDebugEnabled()) {
                    logger.debug("entering LOOKING_FOR_CREATE state: " + deleteName);
                }
                internalState = InternalState.LOOKING_FOR_CREATE;
                ArrayList<Command> commands = new ArrayList<Command>();
                ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                commands.add(new DeleteFileCommand(d.getName(), d.getRootNodeRef(), d.getPath()));
                postCommitCommands.add(newDeleteFileCallbackCommand());
                return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
            } else {
                // anything else bomb out
                if (logger.isDebugEnabled()) {
                    logger.debug("State error, expected a DELETE");
                }
                isComplete = true;
            }
            break;
        case LOOKING_FOR_CREATE:
            /**
             * Looking for a create operation of the deleted file
             */
            if (operation instanceof CreateFileOperation) {
                CreateFileOperation c = (CreateFileOperation) operation;
                if (c.getName().equalsIgnoreCase(deleteName)) {
                    isComplete = true;
                    if (originalNodeRef != null) {
                        logger.debug("Scenario fires:" + this);
                        return new RestoreFileCommand(c.getName(), c.getRootNodeRef(), c.getPath(), c.getAllocationSize(), originalNodeRef);
                    }
                    return null;
                }
            }
    }
    return null;
}

Example 12 with CompoundCommand

use of org.alfresco.filesys.repo.rules.commands.CompoundCommand in project alfresco-repository by Alfresco.

the class CommandExecutorImpl method executeInternal.

/**
 * @param sess SrvSession
 * @param tree TreeConnection
 * @param command Command
 * @param result Object
 * @return Object
 * @throws IOException
 */
private Object executeInternal(SrvSession sess, TreeConnection tree, Command command, Object result) throws IOException {
    FileFilterMode.setClient(ClientHelper.getClient(sess));
    try {
        if (command instanceof CompoundCommand) {
            Object ret = null;
            logger.debug("compound command received");
            CompoundCommand x = (CompoundCommand) command;
            for (Command compoundPart : x.getCommands()) {
                logger.debug("running part of compound command");
                Object val = executeInternal(sess, tree, compoundPart, result);
                if (val != null) {
                    // Return the value from the last command.
                    ret = val;
                }
            }
            return ret;
        } else if (command instanceof CreateFileCommand) {
            logger.debug("create file command");
            CreateFileCommand create = (CreateFileCommand) command;
            return repositoryDiskInterface.createFile(create.getRootNode(), create.getPath(), create.getAllocationSize(), create.isHidden());
        } else if (command instanceof RestoreFileCommand) {
            logger.debug("restore file command");
            RestoreFileCommand restore = (RestoreFileCommand) command;
            return repositoryDiskInterface.restoreFile(sess, tree, restore.getRootNode(), restore.getPath(), restore.getAllocationSize(), restore.getOriginalNodeRef());
        } else if (command instanceof DeleteFileCommand) {
            logger.debug("delete file command");
            DeleteFileCommand delete = (DeleteFileCommand) command;
            return repositoryDiskInterface.deleteFile2(sess, tree, delete.getRootNode(), delete.getPath());
        } else if (command instanceof OpenFileCommand) {
            logger.debug("open file command");
            OpenFileCommand o = (OpenFileCommand) command;
            OpenFileMode mode = o.getMode();
            return repositoryDiskInterface.openFile(sess, tree, o.getRootNodeRef(), o.getPath(), mode, o.isTruncate());
        } else if (command instanceof CloseFileCommand) {
            logger.debug("close file command");
            CloseFileCommand c = (CloseFileCommand) command;
            return repositoryDiskInterface.closeFile(tree, c.getRootNodeRef(), c.getPath(), c.getNetworkFile());
        } else if (command instanceof ReduceQuotaCommand) {
            logger.debug("reduceQuota file command");
            ReduceQuotaCommand r = (ReduceQuotaCommand) command;
            repositoryDiskInterface.reduceQuota(sess, tree, r.getNetworkFile());
        } else if (command instanceof RenameFileCommand) {
            logger.debug("rename command");
            RenameFileCommand rename = (RenameFileCommand) command;
            repositoryDiskInterface.renameFile(rename.getRootNode(), rename.getFromPath(), rename.getToPath(), rename.isSoft(), false);
        } else if (command instanceof MoveFileCommand) {
            logger.debug("move command");
            MoveFileCommand move = (MoveFileCommand) command;
            repositoryDiskInterface.renameFile(move.getRootNode(), move.getFromPath(), move.getToPath(), false, move.isMoveAsSystem());
        } else if (command instanceof CopyContentCommand) {
            if (logger.isDebugEnabled()) {
                logger.debug("Copy content command - copy content");
            }
            CopyContentCommand copy = (CopyContentCommand) command;
            repositoryDiskInterface.copyContent(copy.getRootNode(), copy.getFromPath(), copy.getToPath());
        } else if (command instanceof DoNothingCommand) {
            if (logger.isDebugEnabled()) {
                logger.debug("Do Nothing Command - doing nothing");
            }
        } else if (command instanceof ResultCallback) {
            if (logger.isDebugEnabled()) {
                logger.debug("Result Callback");
            }
            ResultCallback callback = (ResultCallback) command;
            callback.execute(result);
        } else if (command instanceof RemoveTempFileCommand) {
            RemoveTempFileCommand r = (RemoveTempFileCommand) command;
            if (logger.isDebugEnabled()) {
                logger.debug("Remove Temp File:" + r.getNetworkFile());
            }
            File file = r.getNetworkFile().getFile();
            boolean isDeleted = file.delete();
            if (!isDeleted) {
                logger.debug("unable to delete temp file:" + r.getNetworkFile() + ", closed=" + r.getNetworkFile().isClosed());
                /*
                     * Unable to delete temporary file
                     * Could be a bug with the file handle not being closed, but yourkit does not
                     * find anything awry.
                     * There are reported Windows JVM bugs such as 4715154 ... 
                     */
                FileOutputStream fos = new FileOutputStream(file);
                FileChannel outChan = null;
                try {
                    outChan = fos.getChannel();
                    outChan.truncate(0);
                } catch (IOException e) {
                    logger.debug("unable to clean up file", e);
                } finally {
                    if (outChan != null) {
                        try {
                            outChan.close();
                        } catch (IOException e) {
                        }
                    }
                    fos.close();
                }
            }
        } else if (command instanceof ReturnValueCommand) {
            ReturnValueCommand r = (ReturnValueCommand) command;
            if (logger.isDebugEnabled()) {
                logger.debug("Return value");
            }
            return r.getReturnValue();
        } else if (command instanceof RemoveNoContentFileOnError) {
            RemoveNoContentFileOnError r = (RemoveNoContentFileOnError) command;
            if (logger.isDebugEnabled()) {
                logger.debug("Remove no content file on error");
            }
            repositoryDiskInterface.deleteEmptyFile(r.getRootNodeRef(), r.getPath());
        }
    } finally {
        FileFilterMode.clearClient();
    }
    return null;
}

Example 13 with CompoundCommand

use of org.alfresco.filesys.repo.rules.commands.CompoundCommand in project alfresco-repository by Alfresco.

the class CommandExecutorImpl method execute.

@Override
public Object execute(final SrvSession sess, final TreeConnection tree, final Command command) throws IOException {
    TxnReadState readState = command.getTransactionRequired();
    Object ret = null;
    // No transaction required.
    if (readState == TxnReadState.TXN_NONE) {
        ret = executeInternal(sess, tree, command, null);
    } else {
        // Yes a transaction is required.
        RetryingTransactionHelper helper = transactionService.getRetryingTransactionHelper();
        boolean readOnly = readState == TxnReadState.TXN_READ_ONLY;
        RetryingTransactionCallback<Object> cb = new RetryingTransactionCallback<Object>() {

            /**
             * Perform a set of commands as a unit of transactional work.
             *
             * @return              Return the result of the unit of work
             * @throws IOException
             */
            public Object execute() throws IOException {
                try {
                    return executeInternal(sess, tree, command, null);
                } catch (IOException e) {
                    // Ensure original checked IOExceptions get propagated
                    throw new PropagatingException(e);
                }
            }
        };
        try {
            ret = helper.doInTransaction(cb, readOnly);
        } catch (PropagatingException pe) {
            if (command instanceof CompoundCommand) {
                if (logger.isDebugEnabled()) {
                    logger.debug("error executing command :command" + command, pe);
                }
                CompoundCommand c = (CompoundCommand) command;
                // Error Callback Here ?
                List<Command> commands = c.getPostErrorCommands();
                if (commands != null) {
                    for (Command c2 : commands) {
                        try {
                            executeInternal(sess, tree, c2, ret);
                        } catch (Throwable t) {
                            logger.warn("caught and ignored exception from error handler", t);
                        // Swallow exception from error handler.
                        }
                    }
                }
            }
            // Unwrap checked exceptions
            throw (IOException) pe.getCause();
        }
    }
    /**
     * execute post commit commands.
     */
    if (command instanceof CompoundCommand) {
        logger.debug("post commit of compound command");
        CompoundCommand c = (CompoundCommand) command;
        List<Command> commands = c.getPostCommitCommands();
        if (commands != null) {
            for (Command c2 : commands) {
                // TODO - what about exceptions from post commit?
                executeInternal(sess, tree, c2, ret);
            }
        }
    }
    return ret;
}