Add Apache MINA SftpEventListener

- republish certain events as `ApplicationEvent`s.

* * Add ApacheMinaFtplet to provide the same functionality with FTP
* Fix typo

* * Polishing javadocs and event toString() methods

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/ApacheMinaSftpEvent.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import org.apache.sshd.server.session.ServerSession;
+
+import org.springframework.integration.file.remote.server.FileServerEvent;
+
+/**
+ * {@code ApplicationEvent} generated from Apache Mina sftp events.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public abstract class ApacheMinaSftpEvent extends FileServerEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	public ApacheMinaSftpEvent(Object source) {
+		super(source);
+	}
+
+	public ApacheMinaSftpEvent(Object source, Throwable cause) {
+		super(source, cause);
+	}
+
+	public ServerSession getSession() {
+		return (ServerSession) source;
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/ApacheMinaSftpEventListener.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import java.io.IOException;
+import java.nio.file.CopyOption;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Map;
+
+import org.apache.sshd.server.session.ServerSession;
+import org.apache.sshd.server.subsystem.sftp.FileHandle;
+import org.apache.sshd.server.subsystem.sftp.SftpEventListener;
+
+import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationEventPublisherAware;
+import org.springframework.util.Assert;
+
+/**
+ * A listener for SFTP events emitted by an Apache Mina sshd/sftp server.
+ * It emits selected events as Spring Framework {@code ApplicationEvent}s
+ * which are subclasses of {@link ApacheMinaSftpEvent}.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class ApacheMinaSftpEventListener implements SftpEventListener, ApplicationEventPublisherAware, BeanNameAware, InitializingBean {
+
+	private ApplicationEventPublisher applicationEventPublisher;
+
+	private String beanName;
+
+	@Override
+	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
+		this.applicationEventPublisher = applicationEventPublisher;
+	}
+
+	protected ApplicationEventPublisher getApplicationEventPublisher() {
+		return this.applicationEventPublisher;
+	}
+
+	@Override
+	public void setBeanName(String name) {
+		this.beanName = name;
+	}
+
+	public String getBeanName() {
+		return this.beanName;
+	}
+
+	@Override
+	public void afterPropertiesSet() {
+		Assert.state(this.applicationEventPublisher != null, "An ApplicationEventPublisher is required");
+	}
+
+	@Override
+	public void initialized(ServerSession session, int version) {
+		this.applicationEventPublisher.publishEvent(new SessionOpenedEvent(session, version));
+	}
+
+	@Override
+	public void destroying(ServerSession session) throws IOException {
+		this.applicationEventPublisher.publishEvent(new SessionClosedEvent(session));
+	}
+
+	@Override
+	public void created(ServerSession session, Path path, Map<String, ?> attrs, Throwable thrown) {
+		this.applicationEventPublisher.publishEvent(new DirectoryCreatedEvent(session, path, attrs));
+	}
+
+	@Override
+	public void removed(ServerSession session, Path path, boolean isDirectory, Throwable thrown) {
+		this.applicationEventPublisher.publishEvent(new PathRemovedEvent(session, path, isDirectory, thrown));
+	}
+
+	@Override
+	public void written(ServerSession session, String remoteHandle, FileHandle localHandle, long offset, byte[] data,
+			int dataOffset, int dataLen, Throwable thrown) {
+
+		this.applicationEventPublisher.publishEvent(new FileWrittenEvent(session, remoteHandle, localHandle.getFile(),
+				dataLen, thrown));
+	}
+
+	@Override
+	public void moved(ServerSession session, Path srcPath, Path dstPath, Collection<CopyOption> opts,
+			Throwable thrown) {
+
+		this.applicationEventPublisher.publishEvent(new PathMovedEvent(session, srcPath, dstPath, thrown));
+	}
+
+	@Override
+	public String toString() {
+		return "ApacheMinaSftpEventListener [beanName=" + this.beanName + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/DirectoryCreatedEvent.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import java.nio.file.Path;
+import java.util.Map;
+
+/**
+ * An event emitted when a directory is created.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class DirectoryCreatedEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	private final Path path;
+
+	private final Map<String, ?> attrs;
+
+	public DirectoryCreatedEvent(Object source, Path path, Map<String, ?> attrs) {
+		super(source);
+		this.path = path;
+		this.attrs = attrs;
+	}
+
+	public Path getPath() {
+		return this.path;
+	}
+
+	public Map<String, ?> getAttrs() {
+		return this.attrs;
+	}
+
+	@Override
+	public String toString() {
+		return "DirectoryCreatedEvent [path=" + this.path
+				+ ", attrs=" + this.attrs
+				+ ", clientAddress=" + getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/FileWrittenEvent.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import java.nio.file.Path;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * An event that is emitted when a file is written.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class FileWrittenEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	private final String remoteHandle;
+
+	private final Path file;
+
+	private final int dataLen;
+
+	public FileWrittenEvent(Object source, String remoteHandle, Path file, int dataLen, @Nullable Throwable thrown) {
+		super(source, thrown);
+		this.remoteHandle = remoteHandle;
+		this.file = file;
+		this.dataLen = dataLen;
+	}
+
+	public String getRemoteHandle() {
+		return this.remoteHandle;
+	}
+
+	public Path getFile() {
+		return this.file;
+	}
+
+	public int getDataLen() {
+		return this.dataLen;
+	}
+
+	@Override
+	public String toString() {
+		return "FileWrittenEvent [remoteHandle=" + this.remoteHandle
+				+ ", file=" + this.file
+				+ ", dataLen=" + this.dataLen
+				+ (this.cause == null ? "" : ", cause=" + this.cause)
+				+ ", clientAddress=" + getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/PathMovedEvent.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import java.nio.file.Path;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * An event emitted when a path is moved.
+ * @author Gary Russell
+ *
+ * @since 5.2
+ *
+ */
+public class PathMovedEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	private final Path srcPath;
+
+	private final Path dstPath;
+
+	public PathMovedEvent(Object source, Path srcPath, Path dstPath, @Nullable Throwable thrown) {
+		super(source, thrown);
+		this.srcPath = srcPath;
+		this.dstPath = dstPath;
+	}
+
+	public Path getSrcPath() {
+		return this.srcPath;
+	}
+
+	public Path getDstPath() {
+		return this.dstPath;
+	}
+
+	@Override
+	public String toString() {
+		return "PathMovedEvent [srcPath=" + this.srcPath
+				+ ", dstPath=" + this.dstPath
+				+ (this.cause == null ? "" : ", cause=" + this.cause)
+				+ ", clientAddress=" + getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/PathRemovedEvent.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import java.nio.file.Path;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * An event emitted when a file or directory is removed.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class PathRemovedEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	private final Path path;
+
+	private final boolean isDirectory;
+
+	public PathRemovedEvent(Object source, Path path, boolean isDirectory, @Nullable Throwable thrown) {
+		super(source, thrown);
+		this.path = path;
+		this.isDirectory = isDirectory;
+	}
+
+	public Path getPath() {
+		return this.path;
+	}
+
+	public boolean isDirectory() {
+		return this.isDirectory;
+	}
+
+	@Override
+	public String toString() {
+		return "PathRemovedEvent [path=" + this.path
+				+ ", isDirectory=" + this.isDirectory
+				+ (this.cause == null ? "" : ", cause=" + this.cause)
+				+ ", clientAddress=" + getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/SessionClosedEvent.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import org.apache.sshd.server.session.ServerSession;
+
+/**
+ * An event emitted when a session is closed.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class SessionClosedEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	public SessionClosedEvent(ServerSession session) {
+		super(session);
+	}
+
+	@Override
+	public String toString() {
+		return "SessionClosedEvent [clientAddress=" + getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/SessionOpenedEvent.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.sftp.server;
+
+import org.apache.sshd.server.session.ServerSession;
+
+/**
+ * An event emitted when a session is opened.
+ *
+ * @author Gary Russell
+ * @since 5.2
+ *
+ */
+public class SessionOpenedEvent extends ApacheMinaSftpEvent {
+
+	private static final long serialVersionUID = 1L;
+
+	private final int clientVersion;
+
+	public SessionOpenedEvent(ServerSession session, int version) {
+		super(session);
+		this.clientVersion = version;
+	}
+
+	public int getClientVersion() {
+		return this.clientVersion;
+	}
+
+	@Override
+	public String toString() {
+		return "SessionOpenedEvent [clientVersion=" + this.clientVersion + ", clientAddress="
+				+ getSession().getClientAddress() + "]";
+	}
+
+}

spring-integration-sftp/src/main/java/org/springframework/integration/sftp/server/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Provides classes related to SFTP servers.
+ */
+package org.springframework.integration.sftp.server;

spring-integration-sftp/src/test/java/org/springframework/integration/sftp/SftpTestSupport.java

@@ -29,6 +29,7 @@ import org.junit.BeforeClass;
 import org.springframework.integration.file.remote.RemoteFileTestSupport;
 import org.springframework.integration.file.remote.session.CachingSessionFactory;
 import org.springframework.integration.file.remote.session.SessionFactory;
+import org.springframework.integration.sftp.server.ApacheMinaSftpEventListener;
 import org.springframework.integration.sftp.session.DefaultSftpSessionFactory;
 
 import com.jcraft.jsch.ChannelSftp.LsEntry;
@@ -46,6 +47,8 @@ public class SftpTestSupport extends RemoteFileTestSupport {
 
 	private static SshServer server;
 
+	private static ApacheMinaSftpEventListener eventListener = new ApacheMinaSftpEventListener();
+
 	@Override
 	public String getTargetLocalDirectoryName() {
 		return targetLocalDirectory.getAbsolutePath() + File.separator;
@@ -62,7 +65,12 @@ public class SftpTestSupport extends RemoteFileTestSupport {
 		server.setPasswordAuthenticator((username, password, session) -> true);
 		server.setPort(0);
 		server.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(new File("hostkey.ser").toPath()));
-		server.setSubsystemFactories(Collections.singletonList(new SftpSubsystemFactory()));
+		SftpSubsystemFactory sftpFactory = new SftpSubsystemFactory();
+		eventListener.setApplicationEventPublisher((ev) -> {
+			// no-op
+		});
+		sftpFactory.addSftpEventListener(eventListener);
+		server.setSubsystemFactories(Collections.singletonList(sftpFactory));
 		server.setFileSystemFactory(new VirtualFileSystemFactory(remoteTemporaryFolder.getRoot().toPath()));
 		server.start();
 		port = server.getPort();
@@ -78,6 +86,10 @@ public class SftpTestSupport extends RemoteFileTestSupport {
 		return new CachingSessionFactory<>(factory);
 	}
 
+	public static ApacheMinaSftpEventListener eventListener() {
+		return eventListener;
+	}
+
 	@AfterClass
 	public static void stopServer() throws Exception {
 		server.stop();

spring-integration-sftp/src/test/java/org/springframework/integration/sftp/outbound/SftpServerOutboundTests.java

@@ -27,6 +27,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
@@ -40,17 +41,28 @@ import org.junit.runner.RunWith;
 
 import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.integration.channel.DirectChannel;
+import org.springframework.integration.event.inbound.ApplicationEventListeningMessageProducer;
 import org.springframework.integration.file.FileHeaders;
 import org.springframework.integration.file.remote.MessageSessionCallback;
+import org.springframework.integration.file.remote.session.CachingSessionFactory;
 import org.springframework.integration.file.remote.session.Session;
 import org.springframework.integration.file.remote.session.SessionFactory;
 import org.springframework.integration.sftp.SftpTestSupport;
+import org.springframework.integration.sftp.server.ApacheMinaSftpEvent;
+import org.springframework.integration.sftp.server.DirectoryCreatedEvent;
+import org.springframework.integration.sftp.server.FileWrittenEvent;
+import org.springframework.integration.sftp.server.PathMovedEvent;
+import org.springframework.integration.sftp.server.PathRemovedEvent;
+import org.springframework.integration.sftp.server.SessionClosedEvent;
+import org.springframework.integration.sftp.server.SessionOpenedEvent;
 import org.springframework.integration.sftp.session.SftpRemoteFileTemplate;
 import org.springframework.integration.support.MessageBuilder;
 import org.springframework.integration.test.util.TestUtils;
 import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
 import org.springframework.messaging.MessagingException;
 import org.springframework.messaging.PollableChannel;
 import org.springframework.messaging.support.GenericMessage;
@@ -118,6 +130,9 @@ public class SftpServerOutboundTests extends SftpTestSupport {
 	@Autowired
 	private Config config;
 
+	@Autowired
+	private SftpRemoteFileTemplate template;
+
 	@Before
 	public void setup() {
 		this.config.targetLocalDirectoryName = getTargetLocalDirectoryName();
@@ -352,6 +367,9 @@ public class SftpServerOutboundTests extends SftpTestSupport {
 
 	@Test
 	public void testInt3088MPutNotRecursive() throws Exception {
+		resetSessionCache();
+		this.config.events.clear();
+		this.config.latch = new CountDownLatch(1);
 		Session<?> session = sessionFactory.getSession();
 		session.close();
 		session = TestUtils.getPropertyValue(session, "targetSession", Session.class);
@@ -373,8 +391,86 @@ public class SftpServerOutboundTests extends SftpTestSupport {
 				.isIn("sftpTarget/localSource1.txt", "sftpTarget/localSource2.txt");
 		assertThat(out.getPayload().get(1))
 				.isIn("sftpTarget/localSource1.txt", "sftpTarget/localSource2.txt");
-		verify(channel).chmod(384, "sftpTarget/localSource1.txt"); // 384 = 600 octal
-		verify(channel).chmod(384, "sftpTarget/localSource2.txt");
+		verify(channel).chmod(0600, "sftpTarget/localSource1.txt");
+		verify(channel).chmod(0600, "sftpTarget/localSource2.txt");
+		resetSessionCache();
+		assertThat(this.config.latch.await(10, TimeUnit.SECONDS)).isTrue();
+		assertThat(this.config.events).hasSize(6);
+		assertThat(this.config.events.get(0)).isInstanceOf(SessionOpenedEvent.class);
+		assertThat(this.config.events.get(1)).isInstanceOf(FileWrittenEvent.class);
+		assertThat(((FileWrittenEvent) this.config.events.get(1)).getFile().toString())
+				.matches("/sftpTarget/localSource(1|2).txt.writing");
+		assertThat(this.config.events.get(2)).isInstanceOf(PathMovedEvent.class);
+		assertThat(((PathMovedEvent) this.config.events.get(2)).getSrcPath().toString())
+				.matches("/sftpTarget/localSource(1|2).txt.writing");
+		assertThat(((PathMovedEvent) this.config.events.get(2)).getDstPath().toString())
+				.matches("/sftpTarget/localSource(1|2).txt");
+		assertThat(this.config.events.get(3)).isInstanceOf(FileWrittenEvent.class);
+		assertThat(((FileWrittenEvent) this.config.events.get(3)).getFile().toString())
+				.matches("/sftpTarget/localSource(1|2).txt.writing");
+		assertThat(this.config.events.get(4)).isInstanceOf(PathMovedEvent.class);
+		assertThat(((PathMovedEvent) this.config.events.get(4)).getSrcPath().toString())
+				.matches("/sftpTarget/localSource(1|2).txt.writing");
+		assertThat(((PathMovedEvent) this.config.events.get(4)).getDstPath().toString())
+				.matches("/sftpTarget/localSource(1|2).txt");
+		assertThat(this.config.events.get(5)).isInstanceOf(SessionClosedEvent.class);
+		this.config.events.clear();
+		this.config.latch = null;
+	}
+
+	@Test
+	public void allEvents() throws InterruptedException {
+		resetSessionCache();
+		this.config.events.clear();
+		this.config.latch = new CountDownLatch(1);
+		this.template.execute(session -> {
+			assertThat(session.mkdir("/sftpTarget/allEventsDir")).isTrue();
+			session.write(new ByteArrayInputStream("foo".getBytes()), "/sftpTarget/allEventsDir/file.txt");
+			session.append(new ByteArrayInputStream("bar".getBytes()), "/sftpTarget/allEventsDir/file.txt");
+			session.rename("/sftpTarget/allEventsDir/file.txt", "/sftpTarget/allEventsDir/file2.txt");
+			assertThat(session.remove("/sftpTarget/allEventsDir/file2.txt")).isTrue();
+			session.rename("/sftpTarget/allEventsDir", "/sftpTarget/allEventsDir2");
+			session.rmdir("/sftpTarget/allEventsDir2");
+			return null;
+		});
+		resetSessionCache();
+		assertThat(this.config.latch.await(10, TimeUnit.SECONDS)).isTrue();
+		assertThat(this.config.events).hasSize(9);
+		assertThat(this.config.events.get(0)).isInstanceOf(SessionOpenedEvent.class);
+		assertThat(this.config.events.get(1)).isInstanceOf(DirectoryCreatedEvent.class);
+		DirectoryCreatedEvent dce = (DirectoryCreatedEvent) this.config.events.get(1);
+		assertThat(dce.getPath().toString()).isEqualTo("/sftpTarget/allEventsDir");
+		assertThat(this.config.events.get(2)).isInstanceOf(FileWrittenEvent.class);
+		FileWrittenEvent fwe = (FileWrittenEvent) this.config.events.get(2);
+		assertThat(fwe.getFile().toString()).isEqualTo("/sftpTarget/allEventsDir/file.txt");
+		assertThat(fwe.getDataLen()).isEqualTo(3);
+		assertThat(this.config.events.get(3)).isInstanceOf(FileWrittenEvent.class);
+		fwe = (FileWrittenEvent) this.config.events.get(3);
+		assertThat(fwe.getFile().toString()).isEqualTo("/sftpTarget/allEventsDir/file.txt");
+		assertThat(fwe.getDataLen()).isEqualTo(3);
+		assertThat(this.config.events.get(4)).isInstanceOf(PathMovedEvent.class);
+		PathMovedEvent pme = (PathMovedEvent) this.config.events.get(4);
+		assertThat(pme.getSrcPath().toString()).isEqualTo("/sftpTarget/allEventsDir/file.txt");
+		assertThat(pme.getDstPath().toString()).isEqualTo("/sftpTarget/allEventsDir/file2.txt");
+		assertThat(this.config.events.get(5)).isInstanceOf(PathRemovedEvent.class);
+		PathRemovedEvent pre = (PathRemovedEvent) this.config.events.get(5);
+		assertThat(pre.getPath().toString()).isEqualTo("/sftpTarget/allEventsDir/file2.txt");
+		assertThat(pre.isDirectory()).isFalse();
+		assertThat(this.config.events.get(6)).isInstanceOf(PathMovedEvent.class);
+		pme = (PathMovedEvent) this.config.events.get(6);
+		assertThat(pme.getSrcPath().toString()).isEqualTo("/sftpTarget/allEventsDir");
+		assertThat(pme.getDstPath().toString()).isEqualTo("/sftpTarget/allEventsDir2");
+		assertThat(this.config.events.get(7)).isInstanceOf(PathRemovedEvent.class);
+		pre = (PathRemovedEvent) this.config.events.get(7);
+		assertThat(pre.getPath().toString()).isEqualTo("/sftpTarget/allEventsDir2");
+		assertThat(pre.isDirectory()).isTrue();
+		assertThat(this.config.events.get(8)).isInstanceOf(SessionClosedEvent.class);
+		this.config.events.clear();
+		this.config.latch = null;
+	}
+
+	private void resetSessionCache() {
+		((CachingSessionFactory<?>) this.sessionFactory).resetCache();
 	}
 
 	@Test
@@ -488,17 +584,49 @@ public class SftpServerOutboundTests extends SftpTestSupport {
 
 	public static class Config {
 
+		final List<ApacheMinaSftpEvent> events = new ArrayList<>();
+
 		private volatile String targetLocalDirectoryName;
 
+		private volatile CountDownLatch latch;
+
 		@Bean
-		public SessionFactory<LsEntry> sftpSessionFactory() {
+		public SessionFactory<LsEntry> sftpSessionFactory(ApplicationContext context) {
+			SftpServerOutboundTests.eventListener().setApplicationEventPublisher(context);
 			return SftpServerOutboundTests.sessionFactory();
 		}
 
+		@Bean
+		public SftpRemoteFileTemplate template(SessionFactory<LsEntry> sf) {
+			return new SftpRemoteFileTemplate(sf);
+		}
+
 		public String getTargetLocalDirectoryName() {
 			return this.targetLocalDirectoryName;
 		}
 
+		@Bean
+		public ApplicationEventListeningMessageProducer events() {
+			ApplicationEventListeningMessageProducer producer = new ApplicationEventListeningMessageProducer();
+			producer.setEventTypes(ApacheMinaSftpEvent.class);
+			producer.setOutputChannel(eventChannel());
+			return producer;
+		}
+
+		@Bean
+		public MessageChannel eventChannel() {
+			return (msg, timeout) -> {
+				if (this.latch != null) {
+					if (this.events.size() > 0 || msg.getPayload() instanceof SessionOpenedEvent) {
+						this.events.add((ApacheMinaSftpEvent) msg.getPayload());
+						if (msg.getPayload() instanceof SessionClosedEvent) {
+							this.latch.countDown();
+						}
+					}
+				}
+				return true;
+			};
+		}
 	}
 
 }