Refactor HTTP Range support with ResourceRegion

Prior to this commit, the `ResourceHttpMessageConverter` would support
all HTTP Range requests and `MethodProcessors` would "wrap" controller
handler return values with a `HttpRangeResource` to support that use
case in Controllers.

This commit refactors that support in several ways:
* a new ResourceRegion class has been introduced
* a new, separate, ResourceRegionHttpMessageConverter handles the HTTP
range use cases when serving static resources with the
ResourceHttpRequestHandler
* the support of HTTP range requests on Controller handlers has been
removed until a better solution is found

Issue: SPR-14221, SPR-13834

Author: bclozel

spring-core/src/main/java/org/springframework/core/io/ResourceRegion.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2002-2016 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.core.io;
+
+import org.springframework.util.Assert;
+
+/**
+ * Region of a {@link Resource} implementation, materialized by a {@code position}
+ * within the {@link Resource} and a byte {@code count} for the length of that region.
+ * @author Arjen Poutsma
+ * @since 4.3.0
+ */
+public class ResourceRegion {
+
+	private final Resource resource;
+
+	private final long position;
+
+	private final long count;
+
+	/**
+	 * Create a new {@code ResourceRegion} from a given {@link Resource}.
+	 * This region of a resource is reprensented by a start {@code position}
+	 * and a byte {@code count} within the given {@code Resource}.
+	 * @param resource a Resource
+	 * @param position the start position of the region in that resource
+	 * @param count the byte count of the region in that resource
+	 */
+	public ResourceRegion(Resource resource, long position, long count) {
+		Assert.notNull(resource, "'resource' must not be null");
+		Assert.isTrue(position >= 0, "'position' must be larger than or equal to 0");
+		Assert.isTrue(count >= 0, "'count' must be larger than or equal to 0");
+		this.resource = resource;
+		this.position = position;
+		this.count = count;
+	}
+
+	/**
+	 * Return the underlying {@link Resource} for this {@code ResourceRegion}
+	 */
+	public Resource getResource() {
+		return this.resource;
+	}
+
+	/**
+	 * Return the start position of this region in the underlying {@link Resource}
+	 */
+	public long getPosition() {
+		return this.position;
+	}
+
+	/**
+	 * Return the byte count of this region in the underlying {@link Resource}
+	 */
+	public long getCount() {
+		return this.count;
+	}
+}

spring-core/src/main/java/org/springframework/util/StreamUtils.java

@@ -37,6 +37,7 @@
  *
  * @author Juergen Hoeller
  * @author Phillip Webb
+ * @author Brian Clozel
  * @since 3.2.2
  * @see FileCopyUtils
  */
@@ -131,6 +132,43 @@ public static int copy(InputStream in, OutputStream out) throws IOException {
 		return byteCount;
 	}
 
+	/**
+	 * Copy a range of content of the given InputStream to the given OutputStream.
+	 * <p>If the specified range exceeds the length of the InputStream, this copies
+	 * up to the end of the stream and returns the actual number of copied bytes.
+	 * <p>Leaves both streams open when done.
+	 * @param in the InputStream to copy from
+	 * @param out the OutputStream to copy to
+	 * @param start the position to start copying from
+	 * @param end the position to end copying
+	 * @return the number of bytes copied
+	 * @throws IOException in case of I/O errors
+	 * @since 4.3.0
+	 */
+	public static long copyRange(InputStream in, OutputStream out, long start, long end) throws IOException {
+		long skipped = in.skip(start);
+		if (skipped < start) {
+			throw new IOException("Skipped only " + skipped + " bytes out of " + start + " required.");
+		}
+		long bytesToCopy = end - start + 1;
+		byte buffer[] = new byte[StreamUtils.BUFFER_SIZE];
+		while (bytesToCopy > 0) {
+			int bytesRead = in.read(buffer);
+			if (bytesRead == -1) {
+				break;
+			}
+			else if (bytesRead <= bytesToCopy) {
+				out.write(buffer, 0, bytesRead);
+				bytesToCopy -= bytesRead;
+			}
+			else {
+				out.write(buffer, 0, (int) bytesToCopy);
+				bytesToCopy = 0;
+			}
+		}
+		return end - start + 1 - bytesToCopy;
+	}
+
 	/**
 	 * Drain the remaining content of the given InputStream.
 	 * Leaves the InputStream open when done.

spring-core/src/test/java/org/springframework/core/io/ResourceRegionTests.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2016 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.core.io;
+
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+
+/**
+ * Unit tests for the {@link ResourceRegion} class.
+ *
+ * @author Brian Clozel
+ */
+public class ResourceRegionTests {
+
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowExceptionWithNullResource() {
+		new ResourceRegion(null, 0, 1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowExceptionForNegativePosition() {
+		new ResourceRegion(mock(Resource.class), -1, 1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowExceptionForNegativeCount() {
+		new ResourceRegion(mock(Resource.class), 0, -1);
+	}
+}

spring-core/src/test/java/org/springframework/util/StreamUtilsTests.java

@@ -21,6 +21,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.charset.Charset;
+import java.util.Arrays;
 import java.util.Random;
 import java.util.UUID;
 
@@ -93,6 +94,15 @@ public void copyStream() throws Exception {
 		verify(out, never()).close();
 	}
 
+	@Test
+	public void copyRange() throws Exception {
+		ByteArrayOutputStream out = spy(new ByteArrayOutputStream());
+		StreamUtils.copyRange(new ByteArrayInputStream(bytes), out, 0, 100);
+		byte[] range = Arrays.copyOfRange(bytes, 0, 101);
+		assertThat(out.toByteArray(), equalTo(range));
+		verify(out, never()).close();
+	}
+
 	@Test
 	public void nonClosingInputStream() throws Exception {
 		InputStream source = mock(InputStream.class);

spring-web/src/main/java/org/springframework/http/HttpRange.java

@@ -16,12 +16,16 @@
 
 package org.springframework.http;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceRegion;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
@@ -55,6 +59,30 @@ public abstract class HttpRange {
 	 */
 	public abstract long getRangeEnd(long length);
 
+	/**
+	 * Turn a {@code Resource} into a {@link ResourceRegion} using the range
+	 * information contained in the current {@code HttpRange}.
+	 * @param resource the {@code Resource} to select the region from
+	 * @return the selected region of the given {@code Resource}
+	 * @since 4.3.0
+	 */
+	public ResourceRegion toResourceRegion(Resource resource) {
+		// Don't try to determine contentLength on InputStreamResource - cannot be read afterwards...
+		// Note: custom InputStreamResource subclasses could provide a pre-calculated content length!
+		Assert.isTrue(InputStreamResource.class != resource.getClass(),
+				"Can't convert an InputStreamResource to a ResourceRegion");
+		try {
+			long contentLength = resource.contentLength();
+			Assert.isTrue(contentLength > 0, "Resource content length should be > 0");
+			long start = getRangeStart(contentLength);
+			long end = getRangeEnd(contentLength);
+			return new ResourceRegion(resource, start, end - start + 1);
+		}
+		catch (IOException exc) {
+			throw new IllegalArgumentException("Can't convert this Resource to a ResourceRegion", exc);
+		}
+	}
+
 
 	/**
 	 * Create an {@code HttpRange} from the given position to the end.
@@ -133,6 +161,26 @@ else if (dashIdx == 0) {
 		}
 	}
 
+	/**
+	 * Convert each {@code HttpRange} into a {@code ResourceRegion},
+	 * selecting the appropriate segment of the given {@code Resource}
+	 * using the HTTP Range information.
+	 *
+	 * @param ranges the list of ranges
+	 * @param resource the resource to select the regions from
+	 * @return the list of regions for the given resource
+	 */
+	public static List<ResourceRegion> toResourceRegions(List<HttpRange> ranges, Resource resource) {
+		if(ranges == null || ranges.size() == 0) {
+			return Collections.emptyList();
+		}
+		List<ResourceRegion> regions = new ArrayList<ResourceRegion>(ranges.size());
+		for(HttpRange range : ranges) {
+			regions.add(range.toResourceRegion(resource));
+		}
+		return regions;
+	}
+
 	/**
 	 * Return a string representation of the given list of {@code HttpRange} objects.
 	 * <p>This method can be used to for an {@code Range} header.