SftpInboundFileSynchronizer not synchronizing

Question

I have the following SFTP file synchronizer:

@Bean
public SftpInboundFileSynchronizer sftpInboundFileSynchronizer() {
    SftpInboundFileSynchronizer fileSynchronizer = new SftpInboundFileSynchronizer(sftpSessionFactory());
    fileSynchronizer.setDeleteRemoteFiles(false);
    fileSynchronizer.setRemoteDirectory(applicationProperties.getSftpDirectory());
    CompositeFileListFilter<ChannelSftp.LsEntry> compositeFileListFilter = new CompositeFileListFilter<ChannelSftp.LsEntry>();
    compositeFileListFilter.addFilter(new SftpPersistentAcceptOnceFileListFilter(store, "sftp"));
    compositeFileListFilter.addFilter(new SftpSimplePatternFileListFilter(applicationProperties.getLoadFileNamePattern()));
    fileSynchronizer.setFilter(compositeFileListFilter);
    fileSynchronizer.setPreserveTimestamp(true);
    return fileSynchronizer;
}

When the application first runs, it synchronizes to the local directory with the remote SFTP site directory. However, it fails to pick up any subsequent changes in the remote SFTP directory files.

It is scheduled to poll as follows:

@Bean
@InboundChannelAdapter(autoStartup="true", channel = "sftpChannel", poller = @Poller("pollerMetadata"))
public SftpInboundFileSynchronizingMessageSource sftpMessageSource() {
    SftpInboundFileSynchronizingMessageSource source =
            new SftpInboundFileSynchronizingMessageSource(sftpInboundFileSynchronizer());
    source.setLocalDirectory(applicationProperties.getScheduledLoadDirectory());
    source.setAutoCreateLocalDirectory(true);
    ChainFileListFilter<File> chainFileFilter = new ChainFileListFilter<File>();
    chainFileFilter.addFilter(new LastModifiedFileListFilter());
    FileSystemPersistentAcceptOnceFileListFilter fs = new FileSystemPersistentAcceptOnceFileListFilter(store, "dailyfilesystem");
    fs.setFlushOnUpdate(true);
    chainFileFilter.addFilter(fs);
    source.setLocalFilter(chainFileFilter);
    source.setCountsEnabled(true);
    return source;
}

@Bean
public PollerMetadata pollerMetadata(RetryCompoundTriggerAdvice retryCompoundTriggerAdvice) {
    PollerMetadata pollerMetadata = new PollerMetadata();
    List<Advice> adviceChain = new ArrayList<Advice>();
    adviceChain.add(retryCompoundTriggerAdvice);
    pollerMetadata.setAdviceChain(adviceChain);
    pollerMetadata.setTrigger(compoundTrigger());
    pollerMetadata.setMaxMessagesPerPoll(1);
    return pollerMetadata;
}

@Bean
public CompoundTrigger compoundTrigger() {
    CompoundTrigger compoundTrigger = new CompoundTrigger(primaryTrigger());
    return compoundTrigger;
}

@Bean
public CronTrigger primaryTrigger() {
    return new CronTrigger(applicationProperties.getSchedule());
}

@Bean
public PeriodicTrigger secondaryTrigger() {
    return new PeriodicTrigger(applicationProperties.getRetryInterval());
}

In the afterReceive method of RetryCompoundTriggerAdvice which extends AbstractMessageSourceAdvice, I get a null result after the first run.

How can I configure the synchronizer such that it synchronizes periodically (rather than just once at app startup)?

Update

I have found that when the SFTP site has no file in its directory on my application startup, the SftpInboundFileSynchronizer syncs at every polling interval. So I can see com.jcraft.jsch log statements at every poll. But as soon as a file is found on the SFTP site, it syncs to get that file locally and then syncs no more.

Update 2

My apologies... here's the custom code:

@Component
public class RetryCompoundTriggerAdvice extends AbstractMessageSourceAdvice {

    private final static Logger logger = LoggerFactory.getLogger(RetryCompoundTriggerAdvice.class);

    private final CompoundTrigger compoundTrigger;

    private final Trigger override;

    private final ApplicationProperties applicationProperties;

    private final Mail mail;

    private int attempts = 0;

    private boolean expectedMessage;
    private boolean inProcess;

    public RetryCompoundTriggerAdvice(CompoundTrigger compoundTrigger, 
            @Qualifier("secondaryTrigger") Trigger override, 
            ApplicationProperties applicationProperties,
            Mail mail) {
        this.compoundTrigger = compoundTrigger;
        this.override = override;
        this.applicationProperties = applicationProperties;
        this.mail = mail;
    }

    @Override
    public boolean beforeReceive(MessageSource<?> source) {
        logger.debug("!inProcess is " + !inProcess);
        return !inProcess;
    }

    @Override
    public Message<?> afterReceive(Message<?> result, MessageSource<?> source) {

        if (expectedMessage) {
            logger.info("Received expected load file. Setting cron trigger.");
            this.compoundTrigger.setOverride(null);
            expectedMessage = false;
            return result;
        }

        final int  maxOverrideAttempts = applicationProperties.getMaxFileRetry();

        attempts++;
        if (result == null && attempts < maxOverrideAttempts) {
            logger.info("Unable to find file after " + attempts + " attempt(s). Will reattempt");
            this.compoundTrigger.setOverride(this.override);
        } else if (result == null && attempts >= maxOverrideAttempts) {
            String message = "Unable to find daily file" + 
                    " after " + attempts + 
                    " attempt(s). Will not reattempt since max number of attempts is set at " + 
                    maxOverrideAttempts + "."; 
            logger.warn(message);
            mail.sendAdminsEmail("Missing Load File", message);
            attempts = 0;
            this.compoundTrigger.setOverride(null);
        } else {
            attempts = 0;
            // keep periodically checking until we are certain
            // that this message is the expected message
            this.compoundTrigger.setOverride(this.override);
            inProcess = true;
            logger.info("Found load file");
        }
        return result;
    }

    public void foundExpectedMessage(boolean found) {
        logger.debug("Expected message was found? " + found);
        this.expectedMessage = found;
        inProcess = false;
    }

}

Answer 1

You have the logic:

@Override
public boolean beforeReceive(MessageSource<?> source) {
    logger.debug("!inProcess is " + !inProcess);
    return !inProcess;
}

Let's study its JavaDoc:

/**
 * Subclasses can decide whether to proceed with this poll.
 * @param source the message source.
 * @return true to proceed.
 */
public abstract boolean beforeReceive(MessageSource<?> source);

And the logic around this method:

    Message<?> result = null;
    if (beforeReceive((MessageSource<?>) target)) {
        result = (Message<?>) invocation.proceed();
    }
    return afterReceive(result, (MessageSource<?>) target);

So, we call invocation.proceed() (SFTP synchronization) only if beforeReceive() returns true. In your case it is the case only if !inProcess.

In the afterReceive() implementation you have inProcess = true; in case you have a result - at the first attempt. And looks like you reset it back to the false only when someone calls that foundExpectedMessage().

So, what do you expect from us as an answer to your problem? It is really in your custom code and not related to the Framework. Sorry...