AbstractResource.java

/*
 * Copyright (c) 2015 Data Harmonisation Panel
 * 
 * All rights reserved. This program and the accompanying materials are made
 * available under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Contributors:
 *     Data Harmonisation Panel <http://www.dhpanel.eu>
 */

package eu.esdihumboldt.hale.io.geoserver;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.http.entity.ContentType;

import eu.esdihumboldt.hale.io.geoserver.template.Templates;

/**
 * Base class for classes representing GeoServer resources.
 * 
 * <p>
 * The basic idea is that a resource has a name, a set of attributes (the actual
 * set of attributes depends on the resource type) and a content, which is
 * either read from a template file, or directly from an input stream.
 * </p>
 * 
 * @author Stefano Costa, GeoSolutions
 */
public abstract class AbstractResource implements Resource {

	/**
	 * Default resource content type.
	 */
	public static final ContentType DEF_CONTENT_TYPE = ContentType.APPLICATION_XML
			.withCharset("UTF-8");
	/**
	 * Zipped archive content type.
	 */
	public static final ContentType ZIP_CONTENT_TYPE = ContentType.create("application/zip");

	/**
	 * Resource attributes.
	 */
	protected Map<String, Object> attributes;
	/**
	 * The set of allowed attribute names for this particular resource type.
	 */
	protected Set<String> allowedAttributes;

	/**
	 * Default constructor.
	 * 
	 * <p>
	 * Should be invoked by subclasses.
	 * </p>
	 */
	public AbstractResource() {
		this.attributes = new HashMap<String, Object>();
		this.allowedAttributes = new HashSet<String>();
		this.allowedAttributes.addAll(allowedAttributes());
	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#contentType()
	 */
	@Override
	public ContentType contentType() {
		return DEF_CONTENT_TYPE;
	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#getAttribute(java.lang.String)
	 */
	@Override
	public Object getAttribute(String name) {
		if (name == null || name.isEmpty()) {
			throw new IllegalArgumentException("name must be set");
		}

		return this.attributes.get(name);
	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#setAttribute(java.lang.String,
	 *      java.lang.Object)
	 */
	@Override
	public void setAttribute(String name, Object value) {
		if (name == null || name.isEmpty()) {
			throw new IllegalArgumentException("name must be set");
		}
		if (!this.allowedAttributes.contains(name)) {
			throw new IllegalArgumentException(String.format(
					"Variable \"%s\" not allowed in this resource", name));
		}

		this.attributes.put(name, value);
	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#write(java.io.OutputStream)
	 */
	@Override
	public void write(OutputStream out) throws IOException {

		// unset unspecified variables by setting their value to null
		for (String var : this.allowedAttributes) {
			if (!this.attributes.containsKey(var)) {
				this.attributes.put(var, null);
			}
		}

		InputStream resourceStream = locateResource();
		if (resourceStream != null) {
			BufferedInputStream input = new BufferedInputStream(resourceStream);
			BufferedOutputStream output = new BufferedOutputStream(out);
			try {

				for (int b = input.read(); b >= 0; b = input.read()) {
					output.write(b);
				}
			} finally {
				try {
					input.close();
				} catch (IOException e) {
					// ignore exception on close
				}
				try {
					output.close();
				} catch (IOException e) {
					// ignore exception on close
				}
			}
		}

	}

	/**
	 * Grabs an input stream from which resource content can be read.
	 * 
	 * <p>
	 * If a non-null template location is returned by the
	 * {@link #templateLocation()} method, the returned input stream points to
	 * the result of the merging of the template with the resource; otherwise,
	 * the result of {@link #resourceStream()} is returned.
	 * </p>
	 * 
	 * @return the input stream from which resource content is read
	 * @throws IOException if an I/O error occurs
	 */
	protected InputStream locateResource() throws IOException {

		if (templateLocation() != null && !templateLocation().isEmpty()) {
			// resource is loaded from a template and attributes map is used to
			// interpolate variables in it
			return Templates.getInstance().loadTemplate(templateLocation(), this.attributes);
		}
		else {
			// load resource straight from the classpath
			return resourceStream();
		}

	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#asStream()
	 */
	@Override
	public InputStream asStream() throws IOException {
		ByteArrayInputStream bis = new ByteArrayInputStream(asByteArray());

		return bis;
	}

	/**
	 * @see eu.esdihumboldt.hale.io.geoserver.Resource#asByteArray()
	 */
	@Override
	public byte[] asByteArray() throws IOException {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		try {
			write(bos);

			return bos.toByteArray();
		} finally {
			try {
				bos.close();
			} catch (IOException e) {
				// ignore exception on close
			}
		}
	}

	/**
	 * Should be overridden by sublcasses loading resource content from
	 * template.
	 * 
	 * @return the template location (relative to classpath)
	 */
	protected String templateLocation() {
		return null;
	}

	/**
	 * Should be overridden by subclasses loading resource content from an
	 * {@link InputStream}, e.g. file resources.
	 * 
	 * @return the {@link InputStream} from which resource content should be
	 *         read
	 */
	protected InputStream resourceStream() {
		return null;
	}

	/**
	 * Return the set of allowed attributes.
	 * 
	 * <p>
	 * The method must be implemented by subclasses and is invoked by the
	 * default constructor to populate the {@link #allowedAttributes} set.
	 * </p>
	 * 
	 * @return the set of allowed attributes
	 */
	protected abstract Set<String> allowedAttributes();
}