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

Example 6 with CompoundCommand

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

the class ScenarioCreateShuffleInstance 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 createName:" + createName);
            isComplete = true;
            return null;
        }
    }
    /**
     * Anti-pattern for all states - delete the file we are
     * shuffling
     */
    if (createName != null) {
        if (operation instanceof DeleteFileOperation) {
            DeleteFileOperation d = (DeleteFileOperation) operation;
            if (d.getName().equals(createName)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Anti-pattern : Shuffle file deleted createName:" + createName);
                }
                isComplete = true;
                return null;
            }
        }
    }
    switch(internalState) {
        case NONE:
            // Looking for a create transition
            if (operation instanceof CreateFileOperation) {
                CreateFileOperation c = (CreateFileOperation) operation;
                this.createName = c.getName();
                if (logger.isDebugEnabled()) {
                    logger.debug("entering RENAME state: " + createName);
                }
                internalState = InternalState.RENAME;
                return null;
            } else {
                // anything else bomb out
                if (logger.isDebugEnabled()) {
                    logger.debug("State error, expected a CREATE");
                }
                isComplete = true;
            }
            break;
        case RENAME:
            /**
             * Looking for two renames X(createName) to Y(middle) to Z(end)
             */
            if (operation instanceof RenameFileOperation) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Tracking rename: " + operation);
                }
                RenameFileOperation r = (RenameFileOperation) operation;
                renames.put(r.getFrom(), r.getTo());
                // Now see if this rename makes a pair.
                String middle = renames.get(createName);
                if (middle != null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Got second rename");
                    }
                    String end = renames.get(middle);
                    if (end != null) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Got two renames ");
                        }
                        this.move1 = middle;
                        this.move2 = end;
                        if (logger.isDebugEnabled()) {
                            logger.debug("entering DELETE state");
                        }
                        internalState = InternalState.DELETE;
                        /**
                         * This shuffle reverses the rename out of the way and then copies the
                         * content only.   Finally it moves the temp file into place for the subsequent
                         * delete.
                         * a) Rename Z to Y (Reverse previous move)
                         * b) Copy Content from X to Y
                         * c) Rename X to Z (move temp file out to old location)
                         */
                        if (logger.isDebugEnabled()) {
                            logger.debug("Go and shuffle! createName:" + createName + " move1 " + move1 + " move2 " + move2);
                        }
                        String[] paths = FileName.splitPath(r.getFromPath());
                        String oldFolder = paths[0];
                        // String oldFile = paths[1];
                        ArrayList<Command> commands = new ArrayList<Command>();
                        RenameFileCommand r1 = new RenameFileCommand(end, middle, r.getRootNodeRef(), oldFolder + "\\" + end, oldFolder + "\\" + middle);
                        CopyContentCommand copyContent = new CopyContentCommand(createName, move1, r.getRootNodeRef(), oldFolder + "\\" + createName, oldFolder + "\\" + middle);
                        RenameFileCommand r2 = new RenameFileCommand(createName, end, r.getRootNodeRef(), oldFolder + "\\" + createName, oldFolder + "\\" + end);
                        commands.add(r1);
                        commands.add(copyContent);
                        commands.add(r2);
                        return new CompoundCommand(commands);
                    }
                }
            }
            break;
        case DELETE:
            if (operation instanceof DeleteFileOperation) {
                DeleteFileOperation d = (DeleteFileOperation) operation;
                if (d.getName().equals(move2)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Scenario complete createName:" + createName);
                    }
                    isComplete = true;
                }
            }
            /**
             * Todo consider create shuffle with backup file which will never
             * calls delete - do we need to pattern match on "Backup*".
             * At the moment the delete state does nothing - hence
             * we can simply set complete here for all situations.
             */
            isComplete = true;
            break;
    }
    return null;
}

Example 7 with CompoundCommand

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

the class ScenarioRenameShuffleInstance 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");
        }
        isComplete = true;
        return null;
    }
    switch(state) {
        case NONE:
            if (operation instanceof RenameFileOperation) {
                logger.debug("New scenario initialised");
                RenameFileOperation r = (RenameFileOperation) operation;
                this.from = r.getFrom();
                this.to = r.getTo();
                state = InternalState.INITIALISED;
            }
            break;
        case INITIALISED:
            if (operation instanceof CreateFileOperation) {
                CreateFileOperation c = (CreateFileOperation) operation;
                if (from.equals(c.getName())) {
                    logger.debug("transition to LOOK_FOR_DELETE");
                    state = InternalState.LOOK_FOR_DELETE;
                }
            }
            break;
        case LOOK_FOR_DELETE:
            if (operation instanceof DeleteFileOperation) {
                DeleteFileOperation d = (DeleteFileOperation) operation;
                if (to.equals(d.getName())) {
                    logger.debug("Rename shuffle complete - fire!");
                    String[] paths = FileName.splitPath(d.getPath());
                    String oldFolder = paths[0];
                    /**
                     * Shuffle is as follows
                     * a) Copy content from File to File~
                     * b) Delete File
                     * c) Rename File~ to File
                     */
                    ArrayList<Command> commands = new ArrayList<Command>();
                    CopyContentCommand copyContent = new CopyContentCommand(from, to, d.getRootNodeRef(), oldFolder + "\\" + from, oldFolder + "\\" + to);
                    RenameFileCommand r1 = new RenameFileCommand(to, from, d.getRootNodeRef(), oldFolder + "\\" + to, oldFolder + "\\" + from);
                    DeleteFileCommand d1 = new DeleteFileCommand(from, d.getRootNodeRef(), oldFolder + "\\" + from);
                    commands.add(copyContent);
                    commands.add(d1);
                    commands.add(r1);
                    logger.debug("Scenario complete");
                    isComplete = true;
                    return new CompoundCommand(commands);
                }
            }
    }
    return null;
}

Example 8 with CompoundCommand

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

the class ScenarioTempDeleteShuffleInstance method evaluate.

/**
 * Evaluate the next operation
 * @param 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 lockName:" + lockName);
            isComplete = true;
            return null;
        }
    }
    switch(internalState) {
        case NONE:
            /**
             * Looking for target file being deleted
             *
             * Need to intervene and replace delete with a rename to temp file.
             */
            if (operation instanceof DeleteFileOperation) {
                DeleteFileOperation d = (DeleteFileOperation) operation;
                if (logger.isDebugEnabled()) {
                    logger.debug("entering DELETE_SUBSTITUTED state: " + lockName);
                }
                String tempName = ".shuffle" + d.getName();
                deletes.put(d.getName(), tempName);
                String[] paths = FileName.splitPath(d.getPath());
                String currentFolder = paths[0];
                RenameFileCommand r1 = new RenameFileCommand(d.getName(), tempName, d.getRootNodeRef(), d.getPath(), currentFolder + "\\" + tempName);
                internalState = InternalState.DELETE_SUBSTITUTED;
                return r1;
            } else {
                // anything else bomb out
                if (logger.isDebugEnabled()) {
                    logger.debug("State error, expected a DELETE");
                }
                isComplete = true;
            }
            break;
        case DELETE_SUBSTITUTED:
            /**
             * Looking for a move operation of the deleted file
             */
            if (operation instanceof MoveFileOperation) {
                MoveFileOperation m = (MoveFileOperation) operation;
                String targetFile = m.getTo();
                if (deletes.containsKey(targetFile)) {
                    String tempName = deletes.get(targetFile);
                    String[] paths = FileName.splitPath(m.getToPath());
                    String currentFolder = paths[0];
                    /**
                     * This is where the scenario fires.
                     * a) Rename the temp file back to the targetFile
                     * b) Copy content from moved file
                     * c) Delete rather than move file
                     */
                    logger.debug("scenario fires");
                    ArrayList<Command> commands = new ArrayList<Command>();
                    RenameFileCommand r1 = new RenameFileCommand(tempName, targetFile, m.getRootNodeRef(), currentFolder + "\\" + tempName, m.getToPath());
                    CopyContentCommand copyContent = new CopyContentCommand(m.getFrom(), targetFile, m.getRootNodeRef(), m.getFromPath(), m.getToPath());
                    DeleteFileCommand d1 = new DeleteFileCommand(m.getFrom(), m.getRootNodeRef(), m.getFromPath());
                    commands.add(r1);
                    commands.add(copyContent);
                    commands.add(d1);
                    logger.debug("Scenario complete");
                    isComplete = true;
                    return new CompoundCommand(commands);
                }
            }
    }
    return null;
}

Example 9 with CompoundCommand

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

the class ScenarioRenameDeleteMoveInstance 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");
        }
        isComplete = true;
        return null;
    }
    switch(internalState) {
        case NONE:
            if (operation instanceof RenameFileOperation) {
                RenameFileOperation r = (RenameFileOperation) operation;
                fileMiddle = r.getFrom();
                fileEnd = r.getTo();
                String[] paths = FileName.splitPath(r.getFromPath());
                folderMiddle = paths[0];
                String[] paths2 = FileName.splitPath(r.getToPath());
                folderEnd = paths2[0];
                internalState = InternalState.DELETE;
            } else {
                // anything else bomb out
                if (logger.isDebugEnabled()) {
                    logger.debug("State error, expected a RENAME");
                }
                isComplete = true;
            }
        case DELETE:
            if (operation instanceof DeleteFileOperation) {
                internalState = InternalState.MOVE;
                DeleteFileOperation d = (DeleteFileOperation) operation;
                if (d.getName().equalsIgnoreCase(fileEnd)) {
                    ArrayList<Command> commands = new ArrayList<Command>();
                    ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                    ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                    // Rename node to remove "hidden". In this case node will be moved to the archive store and can be restored later.
                    // This can be replaced with command that removes hidden aspect in future(when ContentDiskDriver2.setFileInformation() method will support hidden attribute)
                    RenameFileCommand r1 = new RenameFileCommand(fileEnd, "tmp" + fileEnd, d.getRootNodeRef(), folderEnd + "\\" + fileEnd, folderEnd + "\\" + "tmp" + fileEnd);
                    fileEnd = "tmp" + fileEnd;
                    commands.add(r1);
                    commands.add(new DeleteFileCommand(fileEnd, d.getRootNodeRef(), folderEnd + "\\" + fileEnd));
                    postCommitCommands.add(newDeleteFileCallbackCommand());
                    return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
                }
            }
            if (operation instanceof CloseFileOperation) {
                CloseFileOperation c = (CloseFileOperation) operation;
                if (c.getNetworkFile().hasDeleteOnClose() && c.getName().equalsIgnoreCase(fileEnd)) {
                    internalState = InternalState.MOVE;
                    ArrayList<Command> commands = new ArrayList<Command>();
                    ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                    ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                    // Rename node to remove "hidden". In this case node will be moved to the archive store and can be restored later.
                    RenameFileCommand r1 = new RenameFileCommand(fileEnd, "tmp" + fileEnd, c.getRootNodeRef(), folderEnd + "\\" + fileEnd, folderEnd + "\\" + "tmp" + fileEnd);
                    fileEnd = "tmp" + fileEnd;
                    commands.add(r1);
                    commands.add(new CloseFileCommand(fileEnd, c.getNetworkFile(), c.getRootNodeRef(), folderEnd + "\\" + fileEnd));
                    postCommitCommands.add(newDeleteFileCallbackCommand());
                    return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
                }
            }
            break;
        case MOVE:
            if (operation instanceof MoveFileOperation && originalNodeRef != null) {
                if (logger.isDebugEnabled()) {
                    logger.info("Tracking rename: " + operation);
                }
                MoveFileOperation m = (MoveFileOperation) operation;
                if (fileMiddle.equalsIgnoreCase(m.getTo())) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Got second rename");
                    }
                    fileFrom = m.getFrom();
                    String[] paths = FileName.splitPath(m.getFromPath());
                    String oldFolder = paths[0];
                    ArrayList<Command> commands = new ArrayList<Command>();
                    RestoreFileCommand rest1 = new RestoreFileCommand(fileEnd, m.getRootNodeRef(), folderEnd, 0, originalNodeRef);
                    RenameFileCommand r1 = new RenameFileCommand(fileEnd, fileMiddle, m.getRootNodeRef(), folderEnd + "\\" + fileEnd, folderMiddle + "\\" + fileMiddle);
                    commands.add(rest1);
                    commands.add(r1);
                    CopyContentCommand copyContent = new CopyContentCommand(fileFrom, fileMiddle, m.getRootNodeRef(), oldFolder + "\\" + fileFrom, folderMiddle + "\\" + fileMiddle);
                    commands.add(copyContent);
                    DeleteFileCommand d1 = new DeleteFileCommand(oldFolder, m.getRootNodeRef(), oldFolder + "\\" + fileFrom);
                    commands.add(d1);
                    isComplete = true;
                    return new CompoundCommand(commands);
                }
            }
            break;
    }
    return null;
}

Example 10 with CompoundCommand

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

the class ScenarioDeleteRenameOrCreateInstance method evaluate.

/**
 * Evaluate the next operation
 * @param 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");
        }
        isComplete = true;
        return null;
    }
    switch(state) {
        case NONE:
            if (operation instanceof CloseFileOperation) {
                CloseFileOperation c = (CloseFileOperation) operation;
                this.name = c.getName();
                logger.debug("New scenario initialised for file " + name);
                state = InternalState.INITIALISED;
                ArrayList<Command> commands = new ArrayList<Command>();
                ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                commands.add(new CloseFileCommand(c.getName(), c.getNetworkFile(), c.getRootNodeRef(), c.getPath()));
                postCommitCommands.add(newDeleteFileCallbackCommand());
                return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
            }
            if (operation instanceof DeleteFileOperation) {
                DeleteFileOperation c = (DeleteFileOperation) operation;
                this.name = c.getName();
                logger.debug("New scenario initialised for file " + name);
                state = InternalState.INITIALISED;
                ArrayList<Command> commands = new ArrayList<Command>();
                ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                commands.add(new DeleteFileCommand(c.getName(), c.getRootNodeRef(), c.getPath()));
                postCommitCommands.add(newDeleteFileCallbackCommand());
                return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
            }
            break;
        case INITIALISED:
            if (operation instanceof CreateFileOperation) {
                CreateFileOperation c = (CreateFileOperation) operation;
                if (c.getName().equalsIgnoreCase(name)) {
                    isComplete = true;
                    if (originalNodeRef != null) {
                        logger.debug("Delete create shuffle fire!:" + this);
                        return new RestoreFileCommand(c.getName(), c.getRootNodeRef(), c.getPath(), c.getAllocationSize(), originalNodeRef);
                    }
                    return null;
                }
            }
            if (operation instanceof RenameFileOperation) {
                RenameFileOperation r = (RenameFileOperation) operation;
                if (name.equals(r.getTo())) {
                    logger.debug("Delete Rename shuffle - fire!");
                    if (originalNodeRef != null) {
                        /**
                         * Shuffle is as follows
                         * a) Copy content from File to File~
                         * b) Delete File
                         * c) Rename File~ to File
                         */
                        ArrayList<Command> commands = new ArrayList<Command>();
                        RestoreFileCommand r1 = new RestoreFileCommand(r.getTo(), r.getRootNodeRef(), r.getToPath(), 0, originalNodeRef);
                        CopyContentCommand copyContent = new CopyContentCommand(r.getFrom(), r.getTo(), r.getRootNodeRef(), r.getFromPath(), r.getToPath());
                        DeleteFileCommand d1 = new DeleteFileCommand(r.getFrom(), r.getRootNodeRef(), r.getFromPath());
                        commands.add(r1);
                        commands.add(copyContent);
                        commands.add(d1);
                        logger.debug("Scenario complete");
                        isComplete = true;
                        return new CompoundCommand(commands);
                    } else {
                        logger.debug("Scenario complete");
                        isComplete = true;
                        return null;
                    }
                }
            }
            if (operation instanceof MoveFileOperation) {
                MoveFileOperation r = (MoveFileOperation) operation;
                if (name.equals(r.getTo())) {
                    logger.debug("Delete Rename shuffle - fire!");
                    if (originalNodeRef != null) {
                        /**
                         * Shuffle is as follows
                         * a) Copy content from File to File~
                         * b) Delete File
                         * c) Rename File~ to File
                         */
                        ArrayList<Command> commands = new ArrayList<Command>();
                        RestoreFileCommand r1 = new RestoreFileCommand(r.getTo(), r.getRootNodeRef(), r.getToPath(), 0, originalNodeRef);
                        CopyContentCommand copyContent = new CopyContentCommand(r.getFrom(), r.getTo(), r.getRootNodeRef(), r.getFromPath(), r.getToPath());
                        DeleteFileCommand d1 = new DeleteFileCommand(r.getFrom(), r.getRootNodeRef(), r.getFromPath());
                        commands.add(r1);
                        commands.add(copyContent);
                        commands.add(d1);
                        logger.debug("Scenario complete");
                        isComplete = true;
                        return new CompoundCommand(commands);
                    } else {
                        logger.debug("Scenario complete");
                        isComplete = true;
                        return null;
                    }
                }
            }
    }
    return null;
}