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

Example 1 with CloseFileCommand

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

the class ScenarioOpenFileInstance method evaluate.

/**
 * Evaluate the next operation
 * @param operation
 */
public Command evaluate(Operation operation) {
    /**
     * Anti Pattern - Delete of the open file.
     */
    if (operation instanceof DeleteFileOperation) {
        DeleteFileOperation d = (DeleteFileOperation) operation;
        if (d.getName() == null) {
            return null;
        }
        if (name.equalsIgnoreCase(d.getName())) {
            logger.debug("Anti-Pattern - delete of the open file, scenario:" + this);
            isComplete = true;
            return null;
        }
    }
    switch(state) {
        case NONE:
            if (operation instanceof CreateFileOperation) {
                CreateFileOperation c = (CreateFileOperation) operation;
                name = c.getName();
                if (name != null) {
                    state = InternalState.OPENING;
                    logger.debug("Create File name:" + name);
                    ArrayList<Command> commands = new ArrayList<Command>();
                    ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                    ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                    commands.add(new CreateFileCommand(c.getName(), c.getRootNodeRef(), c.getPath(), c.getAllocationSize(), c.isHidden()));
                    postCommitCommands.add(newOpenFileCallbackCommand());
                    postErrorCommands.add(newOpenFileErrorCallbackCommand());
                    return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
                }
            } else if (operation instanceof OpenFileOperation) {
                OpenFileOperation o = (OpenFileOperation) operation;
                name = o.getName();
                if (name != null) {
                    state = InternalState.OPENING;
                    logger.debug("Open File name:" + name);
                    ArrayList<Command> commands = new ArrayList<Command>();
                    commands.add(new OpenFileCommand(o.getName(), o.getMode(), o.isTruncate(), o.getRootNodeRef(), o.getPath()));
                    ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                    ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                    postCommitCommands.add(newOpenFileCallbackCommand());
                    postErrorCommands.add(newOpenFileErrorCallbackCommand());
                    return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
                }
            }
            // Scenario Not Started
            logger.debug("Scenario not started - no name");
            isComplete = true;
            return null;
        case OPENING:
            if (operation instanceof OpenFileOperation) {
                OpenFileOperation o = (OpenFileOperation) operation;
                if (o.getName() == null) {
                    return null;
                }
                if (name.equalsIgnoreCase(o.getName())) {
                    /**
                     * TODO What to do here - one thread is in the middle of
                     * opening a file while another tries to open the same file
                     * sleep for a bit? then check state again?  What happens if file
                     * closes while sleeping.   For now log an error.
                     */
                    logger.error("Second open while in opening state. :" + name);
                // isComplete = true;
                // return null;
                }
            }
            /**
             * Anti-pattern : timeout - is this needed ?
             */
            Date now = new Date();
            if (now.getTime() > startTime.getTime() + getTimeout()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Instance in OPENING STATE timed out name" + name);
                }
                isComplete = true;
            }
            return null;
        case ERROR:
            logger.debug("Open has failed :" + name);
            isComplete = true;
            return null;
        case OPEN:
            if (operation instanceof RenameFileOperation) {
                RenameFileOperation r = (RenameFileOperation) operation;
                if (r.getFrom() == null) {
                    return null;
                }
                if (name.equalsIgnoreCase(r.getFrom())) {
                    logger.warn("rename of an open file");
                }
            }
            if (operation instanceof CloseFileOperation) {
                CloseFileOperation c = (CloseFileOperation) operation;
                if (c.getName() == null) {
                    return null;
                }
                if (name.equalsIgnoreCase(c.getName())) {
                    NetworkFile file = c.getNetworkFile();
                    if (isReadOnly(file)) {
                        // Read Only File
                        if (openReadOnlyCount == 1) {
                            if (logger.isDebugEnabled()) {
                                logger.debug("Close of last read only file handle:" + this);
                            }
                            openReadOnlyCount = 0;
                            if (openReadWriteCount <= 0) {
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Scenario is complete:" + this);
                                }
                                isComplete = true;
                            }
                            if (file instanceof TempNetworkFile) {
                                logger.debug("this is the last close of a temp read only file");
                                ArrayList<Command> commands = new ArrayList<Command>();
                                ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                                commands.add(new CloseFileCommand(c.getName(), file, c.getRootNodeRef(), c.getPath()));
                                postCommitCommands.add(new RemoveTempFileCommand((TempNetworkFile) file));
                                return new CompoundCommand(commands, postCommitCommands);
                            } else {
                                return new CloseFileCommand(c.getName(), file, c.getRootNodeRef(), c.getPath());
                            }
                        }
                        if (logger.isDebugEnabled()) {
                            logger.debug("Only decrement count of read only file handle:" + this);
                        }
                        openReadOnlyCount--;
                        return new DoNothingCommand();
                    } else {
                        // Read Only File
                        if (openReadWriteCount == 1) {
                            if (logger.isDebugEnabled()) {
                                logger.debug("Close of last read write file handle:" + this);
                            }
                            openReadWriteCount = 0;
                            if (openReadOnlyCount <= 0) {
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Scenario is complete:" + this);
                                }
                                isComplete = true;
                            }
                            // 
                            ArrayList<Command> commands = new ArrayList<Command>();
                            ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                            ArrayList<Command> postErrorCommands = new ArrayList<Command>();
                            commands.add(new CloseFileCommand(c.getName(), file, c.getRootNodeRef(), c.getPath()));
                            if (c.isDeleteOnClose()) {
                                postCommitCommands.add(new ReduceQuotaCommand(c.getName(), file, c.getRootNodeRef(), c.getPath()));
                            }
                            if (file instanceof TempNetworkFile) {
                                postCommitCommands.add(new RemoveTempFileCommand((TempNetworkFile) file));
                            }
                            return new CompoundCommand(commands, postCommitCommands, postErrorCommands);
                        }
                        if (logger.isDebugEnabled()) {
                            logger.debug("Only decrement count of read write file handle:" + this);
                        }
                        openReadWriteCount--;
                        return new DoNothingCommand();
                    }
                }
            } else if (operation instanceof OpenFileOperation) {
                OpenFileOperation o = (OpenFileOperation) operation;
                if (o.getName() == null) {
                    return null;
                }
                if (name != null && name.equalsIgnoreCase(o.getName())) {
                    if (o.getMode() == OpenFileMode.READ_WRITE) {
                        // This is an open of a read write access
                        if (openReadWriteCount == 0) {
                            logger.debug("Open first read/write from scenario:" + this);
                            ArrayList<Command> commands = new ArrayList<Command>();
                            commands.add(new OpenFileCommand(o.getName(), o.getMode(), o.isTruncate(), o.getRootNodeRef(), o.getPath()));
                            ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                            postCommitCommands.add(newOpenFileCallbackCommand());
                            return new CompoundCommand(commands, postCommitCommands);
                        } else {
                            // TODO Need a permission check here and increment post check
                            openReadWriteCount++;
                            logger.debug("Return already open read/write file handle from scenario:" + this);
                            return new ReturnValueCommand(fileHandleReadWrite);
                        }
                    } else {
                        if (openReadWriteCount > 0) {
                            // however the file is already open for read/write
                            openReadWriteCount++;
                            logger.debug("Return already open read/write file handle from scenario:" + this);
                            return new ReturnValueCommand(fileHandleReadWrite);
                        }
                        if (openReadOnlyCount == 0) {
                            logger.debug("Open first read only from scenario:" + this);
                            ArrayList<Command> commands = new ArrayList<Command>();
                            commands.add(new OpenFileCommand(o.getName(), o.getMode(), o.isTruncate(), o.getRootNodeRef(), o.getPath()));
                            ArrayList<Command> postCommitCommands = new ArrayList<Command>();
                            postCommitCommands.add(newOpenFileCallbackCommand());
                            return new CompoundCommand(commands, postCommitCommands);
                        } else {
                            openReadOnlyCount++;
                            logger.debug("Return already open only file handle from scenario:" + this);
                            return new ReturnValueCommand(fileHandleReadOnly);
                        }
                    }
                }
            }
            break;
    }
    return null;
}

Example 2 with CloseFileCommand

use of org.alfresco.filesys.repo.rules.commands.CloseFileCommand 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 3 with CloseFileCommand

use of org.alfresco.filesys.repo.rules.commands.CloseFileCommand 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;
}

Example 4 with CloseFileCommand

use of org.alfresco.filesys.repo.rules.commands.CloseFileCommand 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;
}