Tcp Doc Polishing

garyrussell · artembilan · commit 6391e4bebf43 · 2019-02-04T14:51:33.000-05:00
Also remove some `this.` method calls.
diff --git a/spring-integration-ip/src/main/java/org/springframework/integration/ip/tcp/connection/TcpNetConnection.java b/spring-integration-ip/src/main/java/org/springframework/integration/ip/tcp/connection/TcpNetConnection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2001-2018 the original author or authors.
+ * Copyright 2001-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.
@@ -81,7 +81,7 @@ public boolean isLongLived() {
 	 */
 	@Override
 	public void close() {
-		this.setNoReadErrorOnClose(true);
+		setNoReadErrorOnClose(true);
 		try {
 			this.socket.close();
 		}
@@ -111,8 +111,8 @@ public synchronized void send(Message<?> message) throws Exception {
 			this.socketOutputStream.flush();
 		}
 		catch (Exception e) {
-			this.publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));
-			this.closeConnection(true);
+			publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));
+			closeConnection(true);
 			throw e;
 		}
 		if (logger.isDebugEnabled()) {
@@ -122,7 +122,8 @@ public synchronized void send(Message<?> message) throws Exception {
 
 	@Override
 	public Object getPayload() throws Exception {
-		return this.getDeserializer().deserialize(inputStream());
+		return getDeserializer()
+				.deserialize(inputStream());
 	}
 
 	@Override
@@ -172,16 +173,16 @@ protected InputStream inputStream() throws IOException {
 	public void run() {
 		boolean okToRun = true;
 		if (logger.isDebugEnabled()) {
-			logger.debug(this.getConnectionId() + " Reading...");
+			logger.debug(getConnectionId() + " Reading...");
 		}
 		while (okToRun) {
 			Message<?> message = null;
 			try {
-				message = this.getMapper().toMessage(this);
+				message = getMapper().toMessage(this);
 				this.lastRead = System.currentTimeMillis();
 			}
 			catch (Exception e) {
-				this.publishConnectionExceptionEvent(e);
+				publishConnectionExceptionEvent(e);
 				if (handleReadException(e)) {
 					okToRun = false;
 				}
@@ -218,55 +219,55 @@ protected boolean handleReadException(Exception e) {
 		 * For client connections, we have to wait for 2 timeouts if the last
 		 * send was within the current timeout.
 		 */
-		if (!this.isServer() && e instanceof SocketTimeoutException) {
+		if (!isServer() && e instanceof SocketTimeoutException) {
 			long now = System.currentTimeMillis();
 			try {
 				int soTimeout = this.socket.getSoTimeout();
 				if (now - this.lastSend < soTimeout && now - this.lastRead < soTimeout * 2) {
 					doClose = false;
 				}
 				if (!doClose && logger.isDebugEnabled()) {
-					logger.debug("Skipping a socket timeout because we have a recent send " + this.getConnectionId());
+					logger.debug("Skipping a socket timeout because we have a recent send " + getConnectionId());
 				}
 			}
 			catch (SocketException e1) {
 				logger.error("Error accessing soTimeout", e1);
 			}
 		}
 		if (doClose) {
-			boolean noReadErrorOnClose = this.isNoReadErrorOnClose();
+			boolean noReadErrorOnClose = isNoReadErrorOnClose();
 			closeConnection(true);
 			if (!(e instanceof SoftEndOfStreamException)) {
 				if (e instanceof SocketTimeoutException) {
 					if (logger.isDebugEnabled()) {
-						logger.debug("Closed socket after timeout:" + this.getConnectionId());
+						logger.debug("Closed socket after timeout:" + getConnectionId());
 					}
 				}
 				else {
 					if (noReadErrorOnClose) {
 						if (logger.isTraceEnabled()) {
 							logger.trace("Read exception " +
-									this.getConnectionId(), e);
+									getConnectionId(), e);
 						}
 						else if (logger.isDebugEnabled()) {
 							logger.debug("Read exception " +
-									this.getConnectionId() + " " +
+									getConnectionId() + " " +
 									e.getClass().getSimpleName() +
 									":" + (e.getCause() != null ? e.getCause() + ":" : "") + e.getMessage());
 						}
 					}
 					else if (logger.isTraceEnabled()) {
 						logger.error("Read exception " +
-								this.getConnectionId(), e);
+								getConnectionId(), e);
 					}
 					else {
 						logger.error("Read exception " +
-								this.getConnectionId() + " " +
+								getConnectionId() + " " +
 								e.getClass().getSimpleName() +
 								":" + (e.getCause() != null ? e.getCause() + ":" : "") + e.getMessage());
 					}
 				}
-				this.sendExceptionToListener(e);
+				sendExceptionToListener(e);
 			}
 		}
 		return doClose;
diff --git a/spring-integration-ip/src/main/java/org/springframework/integration/ip/tcp/connection/TcpNioConnection.java b/spring-integration-ip/src/main/java/org/springframework/integration/ip/tcp/connection/TcpNioConnection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-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.
@@ -115,7 +115,7 @@ public void setPipeTimeout(long pipeTimeout) {
 
 	@Override
 	public void close() {
-		this.setNoReadErrorOnClose(true);
+		setNoReadErrorOnClose(true);
 		doClose();
 	}
 
@@ -144,19 +144,19 @@ public void send(Message<?> message) throws Exception {
 		synchronized (this.socketChannel) {
 			if (this.bufferedOutputStream == null) {
 				int writeBufferSize = this.socketChannel.socket().getSendBufferSize();
-				this.bufferedOutputStream = new BufferedOutputStream(this.getChannelOutputStream(),
+				this.bufferedOutputStream = new BufferedOutputStream(getChannelOutputStream(),
 						writeBufferSize > 0 ? writeBufferSize : 8192);
 			}
-			Object object = this.getMapper().fromMessage(message);
+			Object object = getMapper().fromMessage(message);
 			Assert.state(object != null, "Mapper mapped the message to 'null'.");
 			this.lastSend = System.currentTimeMillis();
 			try {
-				((Serializer<Object>) this.getSerializer()).serialize(object, this.bufferedOutputStream);
+				((Serializer<Object>) getSerializer()).serialize(object, this.bufferedOutputStream);
 				this.bufferedOutputStream.flush();
 			}
 			catch (Exception e) {
-				this.publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));
-				this.closeConnection(true);
+				publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));
+				closeConnection(true);
 				throw e;
 			}
 			if (logger.isDebugEnabled()) {
@@ -167,7 +167,8 @@ public void send(Message<?> message) throws Exception {
 
 	@Override
 	public Object getPayload() throws Exception {
-		return this.getDeserializer().deserialize(inputStream());
+		return getDeserializer()
+				.deserialize(inputStream());
 	}
 
 	@Override
@@ -224,7 +225,7 @@ protected ByteBuffer allocate(int length) {
 	@Override
 	public void run() {
 		if (logger.isTraceEnabled()) {
-			logger.trace(this.getConnectionId() + " Nio message assembler running...");
+			logger.trace(getConnectionId() + " Nio message assembler running...");
 		}
 		boolean moreDataAvailable = true;
 		while (moreDataAvailable) {
@@ -242,8 +243,10 @@ public void run() {
 							catch (RejectedExecutionException e) {
 								this.executionControl.decrementAndGet();
 								if (logger.isInfoEnabled()) {
-									logger.info(getConnectionId() + " Insufficient threads in the assembler fixed thread pool; consider " +
-											"increasing this task executor pool size; data avail: " + this.channelInputStream.available());
+									logger.info(getConnectionId()
+											+ " Insufficient threads in the assembler fixed thread pool; consider "
+											+ "increasing this task executor pool size; data avail: "
+											+ this.channelInputStream.available());
 								}
 							}
 						}
@@ -259,24 +262,24 @@ public void run() {
 				catch (Exception e) {
 					if (logger.isTraceEnabled()) {
 						logger.error("Read exception " +
-								this.getConnectionId(), e);
+								getConnectionId(), e);
 					}
-					else if (!this.isNoReadErrorOnClose()) {
+					else if (!isNoReadErrorOnClose()) {
 						logger.error("Read exception " +
-								this.getConnectionId() + " " +
+								getConnectionId() + " " +
 								e.getClass().getSimpleName() +
 								":" + e.getCause() + ":" + e.getMessage());
 					}
 					else {
 						if (logger.isDebugEnabled()) {
 							logger.debug("Read exception " +
-									this.getConnectionId() + " " +
+									getConnectionId() + " " +
 									e.getClass().getSimpleName() +
 									":" + e.getCause() + ":" + e.getMessage());
 						}
 					}
-					this.closeConnection(true);
-					this.sendExceptionToListener(e);
+					closeConnection(true);
+					sendExceptionToListener(e);
 					return;
 				}
 			}
@@ -301,12 +304,13 @@ else if (!this.isNoReadErrorOnClose()) {
 					}
 					if (moreDataAvailable) {
 						if (logger.isTraceEnabled()) {
-							logger.trace(this.getConnectionId() + " Nio message assembler continuing...");
+							logger.trace(getConnectionId() + " Nio message assembler continuing...");
 						}
 					}
 					else {
 						if (logger.isTraceEnabled()) {
-							logger.trace(this.getConnectionId() + " Nio message assembler exiting... avail: " + this.channelInputStream.available());
+							logger.trace(getConnectionId() + " Nio message assembler exiting... avail: "
+									+ this.channelInputStream.available());
 						}
 					}
 				}
@@ -355,13 +359,13 @@ private synchronized Message<?> convert() throws Exception {
 		}
 		Message<?> message = null;
 		try {
-			message = this.getMapper().toMessage(this);
+			message = getMapper().toMessage(this);
 		}
 		catch (Exception e) {
-			this.closeConnection(true);
+			closeConnection(true);
 			if (e instanceof SocketTimeoutException) {
 				if (logger.isDebugEnabled()) {
-					logger.debug("Closing socket after timeout " + this.getConnectionId());
+					logger.debug("Closing socket after timeout " + getConnectionId());
 				}
 			}
 			else {
@@ -420,7 +424,7 @@ private void doRead() throws Exception {
 			int len = this.socketChannel.read(this.rawBuffer);
 			if (len < 0) {
 				this.writingToPipe = false;
-				this.closeConnection(true);
+				closeConnection(true);
 			}
 			if (logger.isTraceEnabled()) {
 				logger.trace("After read:" + this.rawBuffer.position() + "/" + this.rawBuffer.limit());
@@ -432,13 +436,13 @@ private void doRead() throws Exception {
 			if (logger.isDebugEnabled()) {
 				logger.debug("Read " + this.rawBuffer.limit() + " into raw buffer");
 			}
-			this.sendToPipe(this.rawBuffer);
+			sendToPipe(this.rawBuffer);
 		}
 		catch (RejectedExecutionException e) {
 			throw e;
 		}
 		catch (Exception e) {
-			this.publishConnectionExceptionEvent(e);
+			publishConnectionExceptionEvent(e);
 			throw e;
 		}
 		finally {
@@ -450,7 +454,7 @@ private void doRead() throws Exception {
 	protected void sendToPipe(ByteBuffer rawBuffer) throws IOException {
 		Assert.notNull(rawBuffer, "rawBuffer cannot be null");
 		if (logger.isTraceEnabled()) {
-			logger.trace(this.getConnectionId() + " Sending " + rawBuffer.limit() + " to pipe");
+			logger.trace(getConnectionId() + " Sending " + rawBuffer.limit() + " to pipe");
 		}
 		this.channelInputStream.write(rawBuffer);
 		rawBuffer.clear();
@@ -462,7 +466,7 @@ private void checkForAssembler() {
 				// only execute run() if we don't already have one running
 				this.executionControl.set(1);
 				if (logger.isDebugEnabled()) {
-					logger.debug(this.getConnectionId() + " Running an assembler");
+					logger.debug(getConnectionId() + " Running an assembler");
 				}
 				try {
 					this.taskExecutor.execute2(this);
@@ -487,25 +491,25 @@ private void checkForAssembler() {
 	 */
 	public void readPacket() {
 		if (logger.isDebugEnabled()) {
-			logger.debug(this.getConnectionId() + " Reading...");
+			logger.debug(getConnectionId() + " Reading...");
 		}
 		try {
 			doRead();
 		}
 		catch (ClosedChannelException cce) {
 			if (logger.isDebugEnabled()) {
-				logger.debug(this.getConnectionId() + " Channel is closed");
+				logger.debug(getConnectionId() + " Channel is closed");
 			}
-			this.closeConnection(true);
+			closeConnection(true);
 		}
 		catch (RejectedExecutionException e) {
 			throw e;
 		}
 		catch (Exception e) {
 			logger.error("Exception on Read " +
-					this.getConnectionId() + " " +
+					getConnectionId() + " " +
 					e.getMessage(), e);
-			this.closeConnection(true);
+			closeConnection(true);
 		}
 	}
 
@@ -514,7 +518,7 @@ public void readPacket() {
 	 */
 	void timeout() {
 		this.timedOut = true;
-		this.closeConnection(true);
+		closeConnection(true);
 	}
 
 	/**
diff --git a/src/reference/asciidoc/ip.adoc b/src/reference/asciidoc/ip.adoc
@@ -291,6 +291,8 @@ public IntegrationFlow udpEchoUpcaseServer() {
 [[tcp-connection-factories]]
 === TCP Connection Factories
 
+==== Overview
+
 For TCP, the configuration of the underlying connection is provided by using a connection factory.
 Two types of connection factory are provided: a client connection factory and a server connection factory.
 Client connection factories establish outgoing connections.
@@ -371,6 +373,8 @@ The following example shows a client connection factory that uses `java.net.Sock
 ----
 ====
 
+==== Message Demarcation (Serializers and Deserializers)
+
 TCP is a streaming protocol.
 This means that some structure has to be provided to data transported over TCP so that the receiver can demarcate the data into discrete messages.
 Connection factories are configured to use serializers and deserializers to convert between the message payload and the bits that are sent over TCP.
@@ -437,6 +441,8 @@ This is similar to the deserializer side of `ByteArrayRawSerializer` above, exce
 Internally, it uses a `ByteArrayOutputStream` that lets the buffer grow as needed.
 The client must close the socket in an orderly manner to signal end of message.
 
+WARNING: This deserializer should only be used when the peer is trusted; it is susceptible to a DoS attach due to out of memory conditions.
+
 The `MapJsonSerializer` uses a Jackson `ObjectMapper` to convert between a `Map` and JSON.
 You can use this serializer in conjunction with a `MessageConvertingTcpMessageMapper` and a `MapMessageConverter` to transfer selected headers and the payload in JSON.
 
@@ -447,8 +453,6 @@ By default, a `ByteArrayLfSerializer` is used, resulting in messages with a form
 The final standard serializer is `org.springframework.core.serializer.DefaultSerializer`, which you can use to convert serializable objects with Java serialization.
 `org.springframework.core.serializer.DefaultDeserializer` is provided for inbound deserialization of streams that contain serializable objects.
 
-To implement a custom serializer and deserializer pair, implement the `org.springframework.core.serializer.Deserializer` and `org.springframework.core.serializer.Serializer` interfaces.
-
 If you do not wish to use the default serializer and deserializer (`ByteArrayCrLfSerializer`), you must set the `serializer` and `deserializer` attributes on the connection factory.
 The following example shows how to do so:
 
@@ -480,6 +484,15 @@ NOTE: You can also modify the attributes of sockets and socket factories.
 See <<ssl-tls>>.
 As noted there, such modifications are possible whether or not SSL is being used.
 
+==== Custom Serializers and Deserializers
+
+If your data is not in a format supported by one of the standard deserializers, you can implement your own; you can also implement a custom serializer.
+
+To implement a custom serializer and deserializer pair, implement the `org.springframework.core.serializer.Deserializer` and `org.springframework.core.serializer.Serializer` interfaces.
+
+When the deserializer detects a closed input stream between messages, it must throw a `SoftEndOfStreamException`; this is a signal to the framework to indicate that the close was "normal".
+If the stream is closed while decoding a message, some other exception should be thrown instead.
+
 [[caching-cf]]
 ==== TCP Caching Client Connection Factory
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2001-2018 the original author or authors.`
	`2`	`+ * Copyright 2001-2019 the original author or authors.`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -81,7 +81,7 @@ public boolean isLongLived() {`
`81`	`81`	`*/`
`82`	`82`	`@Override`
`83`	`83`	`public void close() {`
`84`		`- this.setNoReadErrorOnClose(true);`
	`84`	`+ setNoReadErrorOnClose(true);`
`85`	`85`	`try {`
`86`	`86`	`this.socket.close();`
`87`	`87`	`}`
`@@ -111,8 +111,8 @@ public synchronized void send(Message<?> message) throws Exception {`
`111`	`111`	`this.socketOutputStream.flush();`
`112`	`112`	`}`
`113`	`113`	`catch (Exception e) {`
`114`		`- this.publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));`
`115`		`- this.closeConnection(true);`
	`114`	`+ publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));`
	`115`	`+ closeConnection(true);`
`116`	`116`	`throw e;`
`117`	`117`	`}`
`118`	`118`	`if (logger.isDebugEnabled()) {`
`@@ -122,7 +122,8 @@ public synchronized void send(Message<?> message) throws Exception {`
`122`	`122`
`123`	`123`	`@Override`
`124`	`124`	`public Object getPayload() throws Exception {`
`125`		`- return this.getDeserializer().deserialize(inputStream());`
	`125`	`+ return getDeserializer()`
	`126`	`+ .deserialize(inputStream());`
`126`	`127`	`}`
`127`	`128`
`128`	`129`	`@Override`
`@@ -172,16 +173,16 @@ protected InputStream inputStream() throws IOException {`
`172`	`173`	`public void run() {`
`173`	`174`	`boolean okToRun = true;`
`174`	`175`	`if (logger.isDebugEnabled()) {`
`175`		`- logger.debug(this.getConnectionId() + " Reading...");`
	`176`	`+ logger.debug(getConnectionId() + " Reading...");`
`176`	`177`	`}`
`177`	`178`	`while (okToRun) {`
`178`	`179`	`Message<?> message = null;`
`179`	`180`	`try {`
`180`		`- message = this.getMapper().toMessage(this);`
	`181`	`+ message = getMapper().toMessage(this);`
`181`	`182`	`this.lastRead = System.currentTimeMillis();`
`182`	`183`	`}`
`183`	`184`	`catch (Exception e) {`
`184`		`- this.publishConnectionExceptionEvent(e);`
	`185`	`+ publishConnectionExceptionEvent(e);`
`185`	`186`	`if (handleReadException(e)) {`
`186`	`187`	`okToRun = false;`
`187`	`188`	`}`
`@@ -218,55 +219,55 @@ protected boolean handleReadException(Exception e) {`
`218`	`219`	`* For client connections, we have to wait for 2 timeouts if the last`
`219`	`220`	`* send was within the current timeout.`
`220`	`221`	`*/`
`221`		`- if (!this.isServer() && e instanceof SocketTimeoutException) {`
	`222`	`+ if (!isServer() && e instanceof SocketTimeoutException) {`
`222`	`223`	`long now = System.currentTimeMillis();`
`223`	`224`	`try {`
`224`	`225`	`int soTimeout = this.socket.getSoTimeout();`
`225`	`226`	`if (now - this.lastSend < soTimeout && now - this.lastRead < soTimeout * 2) {`
`226`	`227`	`doClose = false;`
`227`	`228`	`}`
`228`	`229`	`if (!doClose && logger.isDebugEnabled()) {`
`229`		`- logger.debug("Skipping a socket timeout because we have a recent send " + this.getConnectionId());`
	`230`	`+ logger.debug("Skipping a socket timeout because we have a recent send " + getConnectionId());`
`230`	`231`	`}`
`231`	`232`	`}`
`232`	`233`	`catch (SocketException e1) {`
`233`	`234`	`logger.error("Error accessing soTimeout", e1);`
`234`	`235`	`}`
`235`	`236`	`}`
`236`	`237`	`if (doClose) {`
`237`		`- boolean noReadErrorOnClose = this.isNoReadErrorOnClose();`
	`238`	`+ boolean noReadErrorOnClose = isNoReadErrorOnClose();`
`238`	`239`	`closeConnection(true);`
`239`	`240`	`if (!(e instanceof SoftEndOfStreamException)) {`
`240`	`241`	`if (e instanceof SocketTimeoutException) {`
`241`	`242`	`if (logger.isDebugEnabled()) {`
`242`		`- logger.debug("Closed socket after timeout:" + this.getConnectionId());`
	`243`	`+ logger.debug("Closed socket after timeout:" + getConnectionId());`
`243`	`244`	`}`
`244`	`245`	`}`
`245`	`246`	`else {`
`246`	`247`	`if (noReadErrorOnClose) {`
`247`	`248`	`if (logger.isTraceEnabled()) {`
`248`	`249`	`logger.trace("Read exception " +`
`249`		`- this.getConnectionId(), e);`
	`250`	`+ getConnectionId(), e);`
`250`	`251`	`}`
`251`	`252`	`else if (logger.isDebugEnabled()) {`
`252`	`253`	`logger.debug("Read exception " +`
`253`		`- this.getConnectionId() + " " +`
	`254`	`+ getConnectionId() + " " +`
`254`	`255`	`e.getClass().getSimpleName() +`
`255`	`256`	`":" + (e.getCause() != null ? e.getCause() + ":" : "") + e.getMessage());`
`256`	`257`	`}`
`257`	`258`	`}`
`258`	`259`	`else if (logger.isTraceEnabled()) {`
`259`	`260`	`logger.error("Read exception " +`
`260`		`- this.getConnectionId(), e);`
	`261`	`+ getConnectionId(), e);`
`261`	`262`	`}`
`262`	`263`	`else {`
`263`	`264`	`logger.error("Read exception " +`
`264`		`- this.getConnectionId() + " " +`
	`265`	`+ getConnectionId() + " " +`
`265`	`266`	`e.getClass().getSimpleName() +`
`266`	`267`	`":" + (e.getCause() != null ? e.getCause() + ":" : "") + e.getMessage());`
`267`	`268`	`}`
`268`	`269`	`}`
`269`		`- this.sendExceptionToListener(e);`
	`270`	`+ sendExceptionToListener(e);`
`270`	`271`	`}`
`271`	`272`	`}`
`272`	`273`	`return doClose;`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2002-2018 the original author or authors.`
	`2`	`+ * Copyright 2002-2019 the original author or authors.`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -115,7 +115,7 @@ public void setPipeTimeout(long pipeTimeout) {`
`115`	`115`
`116`	`116`	`@Override`
`117`	`117`	`public void close() {`
`118`		`- this.setNoReadErrorOnClose(true);`
	`118`	`+ setNoReadErrorOnClose(true);`
`119`	`119`	`doClose();`
`120`	`120`	`}`
`121`	`121`
`@@ -144,19 +144,19 @@ public void send(Message<?> message) throws Exception {`
`144`	`144`	`synchronized (this.socketChannel) {`
`145`	`145`	`if (this.bufferedOutputStream == null) {`
`146`	`146`	`int writeBufferSize = this.socketChannel.socket().getSendBufferSize();`
`147`		`- this.bufferedOutputStream = new BufferedOutputStream(this.getChannelOutputStream(),`
	`147`	`+ this.bufferedOutputStream = new BufferedOutputStream(getChannelOutputStream(),`
`148`	`148`	`writeBufferSize > 0 ? writeBufferSize : 8192);`
`149`	`149`	`}`
`150`		`- Object object = this.getMapper().fromMessage(message);`
	`150`	`+ Object object = getMapper().fromMessage(message);`
`151`	`151`	`Assert.state(object != null, "Mapper mapped the message to 'null'.");`
`152`	`152`	`this.lastSend = System.currentTimeMillis();`
`153`	`153`	`try {`
`154`		`- ((Serializer<Object>) this.getSerializer()).serialize(object, this.bufferedOutputStream);`
	`154`	`+ ((Serializer<Object>) getSerializer()).serialize(object, this.bufferedOutputStream);`
`155`	`155`	`this.bufferedOutputStream.flush();`
`156`	`156`	`}`
`157`	`157`	`catch (Exception e) {`
`158`		`- this.publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));`
`159`		`- this.closeConnection(true);`
	`158`	`+ publishConnectionExceptionEvent(new MessagingException(message, "Failed TCP serialization", e));`
	`159`	`+ closeConnection(true);`
`160`	`160`	`throw e;`
`161`	`161`	`}`
`162`	`162`	`if (logger.isDebugEnabled()) {`
`@@ -167,7 +167,8 @@ public void send(Message<?> message) throws Exception {`
`167`	`167`
`168`	`168`	`@Override`
`169`	`169`	`public Object getPayload() throws Exception {`
`170`		`- return this.getDeserializer().deserialize(inputStream());`
	`170`	`+ return getDeserializer()`
	`171`	`+ .deserialize(inputStream());`
`171`	`172`	`}`
`172`	`173`
`173`	`174`	`@Override`
`@@ -224,7 +225,7 @@ protected ByteBuffer allocate(int length) {`
`224`	`225`	`@Override`
`225`	`226`	`public void run() {`
`226`	`227`	`if (logger.isTraceEnabled()) {`
`227`		`- logger.trace(this.getConnectionId() + " Nio message assembler running...");`
	`228`	`+ logger.trace(getConnectionId() + " Nio message assembler running...");`
`228`	`229`	`}`
`229`	`230`	`boolean moreDataAvailable = true;`
`230`	`231`	`while (moreDataAvailable) {`
`@@ -242,8 +243,10 @@ public void run() {`
`242`	`243`	`catch (RejectedExecutionException e) {`
`243`	`244`	`this.executionControl.decrementAndGet();`
`244`	`245`	`if (logger.isInfoEnabled()) {`
`245`		`- logger.info(getConnectionId() + " Insufficient threads in the assembler fixed thread pool; consider " +`
`246`		`- "increasing this task executor pool size; data avail: " + this.channelInputStream.available());`
	`246`	`+ logger.info(getConnectionId()`
	`247`	`+ + " Insufficient threads in the assembler fixed thread pool; consider "`
	`248`	`+ + "increasing this task executor pool size; data avail: "`
	`249`	`+ + this.channelInputStream.available());`
`247`	`250`	`}`
`248`	`251`	`}`
`249`	`252`	`}`
`@@ -259,24 +262,24 @@ public void run() {`
`259`	`262`	`catch (Exception e) {`
`260`	`263`	`if (logger.isTraceEnabled()) {`
`261`	`264`	`logger.error("Read exception " +`
`262`		`- this.getConnectionId(), e);`
	`265`	`+ getConnectionId(), e);`
`263`	`266`	`}`
`264`		`- else if (!this.isNoReadErrorOnClose()) {`
	`267`	`+ else if (!isNoReadErrorOnClose()) {`
`265`	`268`	`logger.error("Read exception " +`
`266`		`- this.getConnectionId() + " " +`
	`269`	`+ getConnectionId() + " " +`
`267`	`270`	`e.getClass().getSimpleName() +`
`268`	`271`	`":" + e.getCause() + ":" + e.getMessage());`
`269`	`272`	`}`
`270`	`273`	`else {`
`271`	`274`	`if (logger.isDebugEnabled()) {`
`272`	`275`	`logger.debug("Read exception " +`
`273`		`- this.getConnectionId() + " " +`
	`276`	`+ getConnectionId() + " " +`
`274`	`277`	`e.getClass().getSimpleName() +`
`275`	`278`	`":" + e.getCause() + ":" + e.getMessage());`
`276`	`279`	`}`
`277`	`280`	`}`
`278`		`- this.closeConnection(true);`
`279`		`- this.sendExceptionToListener(e);`
	`281`	`+ closeConnection(true);`
	`282`	`+ sendExceptionToListener(e);`
`280`	`283`	`return;`
`281`	`284`	`}`
`282`	`285`	`}`
`@@ -301,12 +304,13 @@ else if (!this.isNoReadErrorOnClose()) {`
`301`	`304`	`}`
`302`	`305`	`if (moreDataAvailable) {`
`303`	`306`	`if (logger.isTraceEnabled()) {`
`304`		`- logger.trace(this.getConnectionId() + " Nio message assembler continuing...");`
	`307`	`+ logger.trace(getConnectionId() + " Nio message assembler continuing...");`
`305`	`308`	`}`
`306`	`309`	`}`
`307`	`310`	`else {`
`308`	`311`	`if (logger.isTraceEnabled()) {`
`309`		`- logger.trace(this.getConnectionId() + " Nio message assembler exiting... avail: " + this.channelInputStream.available());`
	`312`	`+ logger.trace(getConnectionId() + " Nio message assembler exiting... avail: "`
	`313`	`+ + this.channelInputStream.available());`
`310`	`314`	`}`
`311`	`315`	`}`
`312`	`316`	`}`
`@@ -355,13 +359,13 @@ private synchronized Message<?> convert() throws Exception {`
`355`	`359`	`}`
`356`	`360`	`Message<?> message = null;`
`357`	`361`	`try {`
`358`		`- message = this.getMapper().toMessage(this);`
	`362`	`+ message = getMapper().toMessage(this);`
`359`	`363`	`}`
`360`	`364`	`catch (Exception e) {`
`361`		`- this.closeConnection(true);`
	`365`	`+ closeConnection(true);`
`362`	`366`	`if (e instanceof SocketTimeoutException) {`
`363`	`367`	`if (logger.isDebugEnabled()) {`
`364`		`- logger.debug("Closing socket after timeout " + this.getConnectionId());`
	`368`	`+ logger.debug("Closing socket after timeout " + getConnectionId());`
`365`	`369`	`}`
`366`	`370`	`}`
`367`	`371`	`else {`
`@@ -420,7 +424,7 @@ private void doRead() throws Exception {`
`420`	`424`	`int len = this.socketChannel.read(this.rawBuffer);`
`421`	`425`	`if (len < 0) {`
`422`	`426`	`this.writingToPipe = false;`
`423`		`- this.closeConnection(true);`
	`427`	`+ closeConnection(true);`
`424`	`428`	`}`
`425`	`429`	`if (logger.isTraceEnabled()) {`
`426`	`430`	`logger.trace("After read:" + this.rawBuffer.position() + "/" + this.rawBuffer.limit());`
`@@ -432,13 +436,13 @@ private void doRead() throws Exception {`
`432`	`436`	`if (logger.isDebugEnabled()) {`
`433`	`437`	`logger.debug("Read " + this.rawBuffer.limit() + " into raw buffer");`
`434`	`438`	`}`
`435`		`- this.sendToPipe(this.rawBuffer);`
	`439`	`+ sendToPipe(this.rawBuffer);`
`436`	`440`	`}`
`437`	`441`	`catch (RejectedExecutionException e) {`
`438`	`442`	`throw e;`
`439`	`443`	`}`
`440`	`444`	`catch (Exception e) {`
`441`		`- this.publishConnectionExceptionEvent(e);`
	`445`	`+ publishConnectionExceptionEvent(e);`
`442`	`446`	`throw e;`
`443`	`447`	`}`
`444`	`448`	`finally {`
`@@ -450,7 +454,7 @@ private void doRead() throws Exception {`
`450`	`454`	`protected void sendToPipe(ByteBuffer rawBuffer) throws IOException {`
`451`	`455`	`Assert.notNull(rawBuffer, "rawBuffer cannot be null");`
`452`	`456`	`if (logger.isTraceEnabled()) {`
`453`		`- logger.trace(this.getConnectionId() + " Sending " + rawBuffer.limit() + " to pipe");`
	`457`	`+ logger.trace(getConnectionId() + " Sending " + rawBuffer.limit() + " to pipe");`
`454`	`458`	`}`
`455`	`459`	`this.channelInputStream.write(rawBuffer);`
`456`	`460`	`rawBuffer.clear();`
`@@ -462,7 +466,7 @@ private void checkForAssembler() {`
`462`	`466`	`// only execute run() if we don't already have one running`
`463`	`467`	`this.executionControl.set(1);`
`464`	`468`	`if (logger.isDebugEnabled()) {`
`465`		`- logger.debug(this.getConnectionId() + " Running an assembler");`
	`469`	`+ logger.debug(getConnectionId() + " Running an assembler");`
`466`	`470`	`}`
`467`	`471`	`try {`
`468`	`472`	`this.taskExecutor.execute2(this);`
`@@ -487,25 +491,25 @@ private void checkForAssembler() {`
`487`	`491`	`*/`
`488`	`492`	`public void readPacket() {`
`489`	`493`	`if (logger.isDebugEnabled()) {`
`490`		`- logger.debug(this.getConnectionId() + " Reading...");`
	`494`	`+ logger.debug(getConnectionId() + " Reading...");`
`491`	`495`	`}`
`492`	`496`	`try {`
`493`	`497`	`doRead();`
`494`	`498`	`}`
`495`	`499`	`catch (ClosedChannelException cce) {`
`496`	`500`	`if (logger.isDebugEnabled()) {`
`497`		`- logger.debug(this.getConnectionId() + " Channel is closed");`
	`501`	`+ logger.debug(getConnectionId() + " Channel is closed");`
`498`	`502`	`}`
`499`		`- this.closeConnection(true);`
	`503`	`+ closeConnection(true);`
`500`	`504`	`}`
`501`	`505`	`catch (RejectedExecutionException e) {`
`502`	`506`	`throw e;`
`503`	`507`	`}`
`504`	`508`	`catch (Exception e) {`
`505`	`509`	`logger.error("Exception on Read " +`
`506`		`- this.getConnectionId() + " " +`
	`510`	`+ getConnectionId() + " " +`
`507`	`511`	`e.getMessage(), e);`
`508`		`- this.closeConnection(true);`
	`512`	`+ closeConnection(true);`
`509`	`513`	`}`
`510`	`514`	`}`
`511`	`515`
`@@ -514,7 +518,7 @@ public void readPacket() {`
`514`	`518`	`*/`
`515`	`519`	`void timeout() {`
`516`	`520`	`this.timedOut = true;`
`517`		`- this.closeConnection(true);`
	`521`	`+ closeConnection(true);`
`518`	`522`	`}`
`519`	`523`
`520`	`524`	`/**`