MergedResourceStream.java

/**
 * Copyright 2010 Molindo GmbH
 *
 * 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.wicketstuff.mergedresources.resources;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;

import org.apache.wicket.Application;
import org.apache.wicket.IClusterable;
import org.apache.wicket.WicketRuntimeException;
import org.apache.wicket.util.listener.IChangeListener;
import org.apache.wicket.util.resource.IResourceStream;
import org.apache.wicket.util.resource.ResourceStreamNotFoundException;
import org.apache.wicket.util.resource.locator.ResourceNameIterator;
import org.apache.wicket.util.string.Strings;
import org.apache.wicket.util.time.Time;
import org.apache.wicket.util.watch.IModificationWatcher;
import org.wicketstuff.mergedresources.ResourceSpec;
import org.wicketstuff.mergedresources.preprocess.IResourcePreProcessor;

import at.molindo.utils.io.StreamUtils;

public class MergedResourceStream implements IResourceStream {
	private static final long serialVersionUID = 1L;
	private static transient final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(MergedResourceStream.class);

	private final ResourceSpec[] _specs;
	private Locale _locale;
	private final String _style;
	private LocalizedMergedResourceStream _localizedMergedResourceStream;
	private final IResourcePreProcessor _preProcessor;

	/**
	 * @deprecated use ResourceSpec[] instead of scopes[] and files[]
	 */
	@Deprecated
	public MergedResourceStream(final Class<?>[] scopes, final String[] files, final Locale locale, final String style) {
		this(ResourceSpec.toResourceSpecs(scopes, files), locale, style, null);
	}

	public MergedResourceStream(final ResourceSpec[] specs, final Locale locale, final String style,
			IResourcePreProcessor preProcessor) {
		_specs = specs.clone();
		_locale = locale;
		_style = style;
		_preProcessor = preProcessor;
	}

	@Override
	public void close() throws IOException {
		// do nothing
	}

	@Override
	public String getContentType() {
		return getLocalizedMergedResourceStream().getContentType();
	}

	@Override
	public InputStream getInputStream() throws ResourceStreamNotFoundException {
		return getLocalizedMergedResourceStream().getInputStream();
	}

	@Override
	public Locale getLocale() {
		return _locale;
	}

	@Override
	public long length() {
		return getLocalizedMergedResourceStream().getContent().length;
	}

	@Override
	public void setLocale(final Locale locale) {
		_locale = locale;
	}

	@Override
	public Time lastModifiedTime() {
		return getLocalizedMergedResourceStream().getLastModifiedTime();
	}

	private LocalizedMergedResourceStream getLocalizedMergedResourceStream() {
		synchronized (this) {
			if (_localizedMergedResourceStream == null) {
				_localizedMergedResourceStream = new LocalizedMergedResourceStream();
			}
			return _localizedMergedResourceStream;
		}
	}

	private final class LocalizedMergedResourceStream implements IClusterable {
		private static final long serialVersionUID = 1L;
		private final byte[] _content;
		private final String _contentType;
		private final Time _lastModifiedTime;

		private LocalizedMergedResourceStream() {
			Time max = null;
			// final StringWriter w = new StringWriter(4096);
			ByteArrayOutputStream out = new ByteArrayOutputStream(4096);

			final ArrayList<IResourceStream> resourceStreams = new ArrayList<IResourceStream>(_specs.length);

			String contentType = null;
			for (int i = 0; i < _specs.length; i++) {
				final Class<?> scope = _specs[i].getScope();
				final String fileName = _specs[i].getFile();

				final IResourceStream resourceStream = findResourceStream(scope, fileName);
				if (contentType != null) {
					if (resourceStream.getContentType() != null
							&& !contentType.equalsIgnoreCase(resourceStream.getContentType())) {
						log.warn("content types of merged resources don't match: '" + resourceStream.getContentType()
								+ "' and '" + contentType + "'");
					}
				} else {
					contentType = resourceStream.getContentType();
				}

				try {

					final Time lastModified = resourceStream.lastModifiedTime();
					if (max == null || lastModified != null && lastModified.after(max)) {
						max = lastModified;
					}
					if (i > 0) {
						writeFileSeparator(out);
					}
					// process content from single spec
					byte[] preprocessed = preProcess(_specs[i], StreamUtils.bytes(resourceStream.getInputStream()));
					writeContent(out, new ByteArrayInputStream(preprocessed));
					resourceStreams.add(resourceStream);
				} catch (final IOException e) {
					throw new WicketRuntimeException("failed to read from " + resourceStream, e);
				} catch (final ResourceStreamNotFoundException e) {
					throw new WicketRuntimeException("did not find resource", e);
				} finally {
					try {
						if (resourceStream != null) {
							resourceStream.close();
						}
					} catch (final IOException e) {
						log.warn("error while closing reader", e);
					}
				}

			}
			_contentType = contentType;

			_content = toContent(preProcess(null, out.toByteArray()));
			_lastModifiedTime = max == null ? Time.now() : max;
			watchForChanges(resourceStreams);
		}

		private IResourceStream findResourceStream(final Class<?> scope, final String fileName) {
			// Create the base path
			final String path = Strings.beforeLast(scope.getName(), '.').replace('.', '/') + '/'
					+ Strings.beforeLast(fileName, '.');
			// Iterator over all the combinations
			final ResourceNameIterator iter = new ResourceNameIterator(path, _style, _locale, Strings.afterLast(
					fileName, '.'));

			IResourceStream resourceStream = null;
			while (resourceStream == null && iter.hasNext()) {
				final String resourceName = iter.next();
				resourceStream = Application.get().getResourceSettings().getResourceStreamLocator()
						.locate(scope, resourceName, _style, _locale, null);
			}

			if (resourceStream == null) {
				throw new WicketRuntimeException("did not find IResourceStream for "
						+ Arrays.asList(scope, fileName, _style, _locale));
			}

			return resourceStream;
		}

		private void writeContent(final OutputStream out, final InputStream resourceStream) throws IOException {
			StreamUtils.copy(resourceStream, out);
			out.flush();
		}

		private void writeFileSeparator(ByteArrayOutputStream out) throws IOException {
			out.write(getFileSeparator());
		}

		private byte[] getFileSeparator() {
			return isPlainText() ? "\n\n".getBytes() : new byte[0];
		}

		private void watchForChanges(final List<IResourceStream> resourceStreams) {
			// Watch file in the future
			final IModificationWatcher watcher = Application.get().getResourceSettings().getResourceWatcher(true);
			if (watcher != null) {
				final IChangeListener listener = new IChangeListener() {
					@Override
					public void onChange() {
						log.info("merged resource has changed");
						synchronized (MergedResourceStream.this) {
							for (final IResourceStream resourceStream : resourceStreams) {
								watcher.remove(resourceStream);
							}
							_localizedMergedResourceStream = null;
						}
					}
				};
				for (final IResourceStream resourceStream : resourceStreams) {
					watcher.add(resourceStream, listener);
				}
			}
		}

		public InputStream getInputStream() {
			return new ByteArrayInputStream(getContent());
		}

		public byte[] getContent() {
			return _content;
		}

		public Time getLastModifiedTime() {
			return _lastModifiedTime;
		}

		public String getContentType() {
			return _contentType;
		}
	}

	protected byte[] toContent(final byte[] content) {
		return content;
	}

	public boolean isPlainText() {
		// TODO maybe something smarter?
		return true;
	}

	public byte[] preProcess(ResourceSpec resourceSpec, byte[] content) {
		return _preProcessor != null ? _preProcessor.preProcess(resourceSpec, content) : content;
	}
}