DATAMONGO-1276 - Fixed potential NullPointerExceptions in MongoTemplate.

Triggering data access exception translation could lead to NullPointerException in cases where PersistenceExceptionTranslator returned null because the original exception couldn't be translated and the result was directly used from a throw clause.

This is now fixed by consistently the potentiallyConvertRuntimeException(…) method, which was made static to be able to refer to it from nested static classes.

Refactored Scanner usage to actually close the Scanner instance to prevent a resource leak.

Author: odrotbohm

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java

@@ -340,7 +340,7 @@ public CloseableIterator<T> doInCollection(DBCollection collection) throws Mongo
 
 				ReadDbObjectCallback<T> readCallback = new ReadDbObjectCallback<T>(mongoConverter, entityType);
 
-				return new CloseableIterableCusorAdapter<T>(cursorPreparer.prepare(cursor), exceptionTranslator, readCallback);
+				return new CloseableIterableCursorAdapter<T>(cursorPreparer.prepare(cursor), exceptionTranslator, readCallback);
 			}
 		});
 	}
@@ -444,7 +444,7 @@ public <T> T execute(DbCallback<T> action) {
 			DB db = this.getDb();
 			return action.doInDB(db);
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -460,7 +460,7 @@ public <T> T execute(String collectionName, CollectionCallback<T> callback) {
 			DBCollection collection = getAndPrepareCollection(getDb(), collectionName);
 			return callback.doInCollection(collection);
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1546,10 +1546,17 @@ protected String replaceWithResourceIfNecessary(String function) {
 				throw new InvalidDataAccessApiUsageException(String.format("Resource %s not found!", function));
 			}
 
+			Scanner scanner = null;
+
 			try {
-				return new Scanner(functionResource.getInputStream()).useDelimiter("\\A").next();
+				scanner = new Scanner(functionResource.getInputStream());
+				return scanner.useDelimiter("\\A").next();
 			} catch (IOException e) {
 				throw new InvalidDataAccessApiUsageException(String.format("Cannot read map-reduce file %s!", function), e);
+			} finally {
+				if (scanner != null) {
+					scanner.close();
+				}
 			}
 		}
 
@@ -1812,7 +1819,7 @@ private DBCollection getAndPrepareCollection(DB db, String collectionName) {
 			prepareCollection(collection);
 			return collection;
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1838,7 +1845,7 @@ private <T> T executeFindOneInternal(CollectionCallback<DBObject> collectionCall
 					collectionName)));
 			return result;
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1891,7 +1898,7 @@ private <T> List<T> executeFindMultiInternal(CollectionCallback<DBCursor> collec
 				}
 			}
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1921,7 +1928,7 @@ private void executeQueryInternal(CollectionCallback<DBCursor> collectionCallbac
 			}
 
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -2000,18 +2007,6 @@ protected void handleAnyWriteResultErrors(WriteResult writeResult, DBObject quer
 		}
 	}
 
-	/**
-	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
-	 * exception if the conversation failed. Thus allows safe rethrowing of the return value.
-	 * 
-	 * @param ex
-	 * @return
-	 */
-	private RuntimeException potentiallyConvertRuntimeException(RuntimeException ex) {
-		RuntimeException resolved = this.exceptionTranslator.translateExceptionIfPossible(ex);
-		return resolved == null ? ex : resolved;
-	}
-
 	/**
 	 * Inspects the given {@link CommandResult} for erros and potentially throws an
 	 * {@link InvalidDataAccessApiUsageException} for that error.
@@ -2050,6 +2045,20 @@ private DBObject getMappedSortObject(Query query, Class<?> type) {
 		return queryMapper.getMappedSort(query.getSortObject(), mappingContext.getPersistentEntity(type));
 	}
 
+	/**
+	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
+	 * exception if the conversation failed. Thus allows safe re-throwing of the return value.
+	 * 
+	 * @param ex the exception to translate
+	 * @param exceptionTranslator the {@link PersistenceExceptionTranslator} to be used for translation
+	 * @return
+	 */
+	private static RuntimeException potentiallyConvertRuntimeException(RuntimeException ex,
+			PersistenceExceptionTranslator exceptionTranslator) {
+		RuntimeException resolved = exceptionTranslator.translateExceptionIfPossible(ex);
+		return resolved == null ? ex : resolved;
+	}
+
 	// Callback implementations
 
 	/**
@@ -2292,7 +2301,7 @@ public DBCursor prepare(DBCursor cursor) {
 				}
 
 			} catch (RuntimeException e) {
-				throw potentiallyConvertRuntimeException(e);
+				throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 			}
 
 			return cursorToUse;
@@ -2339,20 +2348,20 @@ public GeoResult<T> doWith(DBObject object) {
 	 * @since 1.7
 	 * @author Thomas Darimont
 	 */
-	static class CloseableIterableCusorAdapter<T> implements CloseableIterator<T> {
+	static class CloseableIterableCursorAdapter<T> implements CloseableIterator<T> {
 
 		private volatile Cursor cursor;
 		private PersistenceExceptionTranslator exceptionTranslator;
 		private DbObjectCallback<T> objectReadCallback;
 
 		/**
-		 * Creates a new {@link CloseableIterableCusorAdapter} backed by the given {@link Cursor}.
+		 * Creates a new {@link CloseableIterableCursorAdapter} backed by the given {@link Cursor}.
 		 * 
 		 * @param cursor
 		 * @param exceptionTranslator
 		 * @param objectReadCallback
 		 */
-		public CloseableIterableCusorAdapter(Cursor cursor, PersistenceExceptionTranslator exceptionTranslator,
+		public CloseableIterableCursorAdapter(Cursor cursor, PersistenceExceptionTranslator exceptionTranslator,
 				DbObjectCallback<T> objectReadCallback) {
 
 			this.cursor = cursor;
@@ -2370,7 +2379,7 @@ public boolean hasNext() {
 			try {
 				return cursor.hasNext();
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			}
 		}
 
@@ -2386,7 +2395,7 @@ public T next() {
 				T converted = objectReadCallback.doWith(item);
 				return converted;
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			}
 		}
 
@@ -2397,7 +2406,7 @@ public void close() {
 			try {
 				c.close();
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			} finally {
 				cursor = null;
 				exceptionTranslator = null;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/CloseableIterableCursorAdapterUnitTests.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2015 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
+ *
+ *      http://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.data.mongodb.core;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.core.MongoTemplate.CloseableIterableCursorAdapter;
+import org.springframework.data.mongodb.core.MongoTemplate.DbObjectCallback;
+import org.springframework.data.util.CloseableIterator;
+
+import com.mongodb.Cursor;
+
+/**
+ * Unit tests for {@link CloseableIterableCursorAdapter}.
+ * 
+ * @author Oliver Gierke
+ * @see DATAMONGO-1276
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class CloseableIterableCursorAdapterUnitTests {
+
+	@Mock PersistenceExceptionTranslator exceptionTranslator;
+	@Mock DbObjectCallback<Object> callback;
+
+	Cursor cursor;
+	CloseableIterator<Object> adapter;
+
+	@Before
+	public void setUp() {
+
+		this.cursor = doThrow(IllegalArgumentException.class).when(mock(Cursor.class));
+		this.adapter = new CloseableIterableCursorAdapter<Object>(cursor, exceptionTranslator, callback);
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotNext() {
+
+		cursor.next();
+		adapter.next();
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotHasNext() {
+
+		cursor.hasNext();
+		adapter.hasNext();
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotClose() {
+
+		cursor.close();
+		adapter.close();
+	}
+}