public void sendMessage()

in modules/transports/core/vfs/src/main/java/org/apache/synapse/transport/vfs/VFSTransportSender.java [106:257]
130 lines of code
35 McCabe index (conditional complexity)

    public void sendMessage(MessageContext msgCtx, String targetAddress,
                            OutTransportInfo outTransportInfo) throws AxisFault {

        if (waitForSynchronousResponse(msgCtx)) {
            throw new AxisFault("The VFS transport doesn't support synchronous responses. " +
                    "Please use the appropriate (out only) message exchange pattern.");
        }

        VFSOutTransportInfo vfsOutInfo = null;

        if (targetAddress != null) {
            vfsOutInfo = new VFSOutTransportInfo(targetAddress, globalFileLockingFlag);
        } else if (outTransportInfo != null && outTransportInfo instanceof VFSOutTransportInfo) {
            vfsOutInfo = (VFSOutTransportInfo) outTransportInfo;
        }

        if (vfsOutInfo != null) {
            FileObject replyFile = null;
            try {
                boolean wasError = true;
                int retryCount = 0;
                int maxRetryCount = vfsOutInfo.getMaxRetryCount();
                long reconnectionTimeout = vfsOutInfo.getReconnectTimeout();
                boolean append = vfsOutInfo.isAppend();
                boolean isUseTempFile = vfsOutInfo.isUseTempFile();
                String tempTargetFileName, actualTargetFileName = null;

                while (wasError) {
                    try {
                        retryCount++;
                        replyFile = fsManager.resolveFile(vfsOutInfo.getOutFileURI());
                    
                        if (replyFile == null) {
                            log.error("replyFile is null");
                            throw new FileSystemException("replyFile is null");
                        }
                        wasError = false;
                                        
                    } catch (FileSystemException e) {
                        log.error("cannot resolve replyFile", e);
                        if(maxRetryCount <= retryCount) {
                            handleException("cannot resolve replyFile repeatedly: "
                                    + e.getMessage(), e);
                        }
                    }
                
                    if (wasError) {
                        try {
                            Thread.sleep(reconnectionTimeout);
                        } catch (InterruptedException e2) {
                            Thread.currentThread().interrupt();
                        }
                    }
                }
                
                if (replyFile.exists()) {
                    if (replyFile.getType() == FileType.FOLDER) {
                        if (isUseTempFile) {
                            tempTargetFileName = VFSUtils.generateTempFileName();
                            actualTargetFileName = VFSUtils.getFileName(msgCtx, vfsOutInfo);
                        } else {
                            tempTargetFileName = VFSUtils.getFileName(msgCtx, vfsOutInfo);
                        }
                        // we need to write a file containing the message to this folder
                        FileObject responseFile = fsManager.resolveFile(replyFile, tempTargetFileName);

                        // if file locking is not disabled acquire the lock
                        // before uploading the file
                        if (vfsOutInfo.isFileLockingEnabled()) {
                            acquireLockForSending(responseFile, vfsOutInfo);
                            if (!responseFile.exists()) {
                                responseFile.createFile();
                            }
                            populateResponseFile(responseFile, msgCtx,append, true);
                            VFSUtils.releaseLock(fsManager, responseFile);
                        } else {
                            if (!responseFile.exists()) {
                                responseFile.createFile();
                            }
                            populateResponseFile(responseFile, msgCtx,append, false);
                        }

                        if (isUseTempFile) {
                            responseFile.moveTo(fsManager.resolveFile(replyFile, actualTargetFileName));
                        }

                    } else if (replyFile.getType() == FileType.FILE) {
                        if (isUseTempFile) {
                            tempTargetFileName = VFSUtils.generateTempFileName();
                            actualTargetFileName = replyFile.getURL().toString();
                            replyFile = getTempFileObject(fsManager, replyFile, tempTargetFileName);
                        }

                        // if file locking is not disabled acquire the lock
                        // before uploading the file
                        if (vfsOutInfo.isFileLockingEnabled()) {
                            acquireLockForSending(replyFile, vfsOutInfo);
                            populateResponseFile(replyFile, msgCtx, append, true);
                            VFSUtils.releaseLock(fsManager, replyFile);
                        } else {
                            populateResponseFile(replyFile, msgCtx, append, false);
                        }

                        if (isUseTempFile) {
                            replyFile.moveTo(fsManager.resolveFile(actualTargetFileName));
                        }
                    } else {
                        handleException("Unsupported reply file type : " + replyFile.getType() +
                                " for file : " + vfsOutInfo.getOutFileURI());
                    }
                } else {
                    if (isUseTempFile) {
                        tempTargetFileName = VFSUtils.generateTempFileName();
                        actualTargetFileName = replyFile.getURL().toString();
                        replyFile = getTempFileObject(fsManager, replyFile, tempTargetFileName);
                    }

                    // if file locking is not disabled acquire the lock before uploading the file
                    if (vfsOutInfo.isFileLockingEnabled()) {
                        acquireLockForSending(replyFile, vfsOutInfo);
                        replyFile.createFile();
                        populateResponseFile(replyFile, msgCtx, append, true);
                        VFSUtils.releaseLock(fsManager, replyFile);
                    } else {
                        replyFile.createFile();
                        populateResponseFile(replyFile, msgCtx, append, false);
                    }

                    if (isUseTempFile) {
                        replyFile.moveTo(fsManager.resolveFile(actualTargetFileName));
                    }
                }
            } catch (FileSystemException e) {
                handleException("Error resolving reply file : " +
                        vfsOutInfo.getOutFileURI(), e);
            } finally {
                if (replyFile != null) {
                    try {
                        if (fsManager!= null &&
                            replyFile.getName() != null && replyFile.getName().getScheme() != null &&
                            replyFile.getName().getScheme().startsWith("file") &&
                            replyFile.getParent() != null && replyFile.getParent().getFileSystem() != null) {
                            fsManager.closeFileSystem(replyFile.getParent().getFileSystem());
                        }
                        replyFile.close();
                    } catch (FileSystemException ignore) {}
                }
            }
        } else {
            handleException("Unable to determine out transport information to send message");
        }
    }