/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.oodt.product.handlers.ofsn;
//JDK imports
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
//APACHE imports
import org.apache.tika.mime.MediaType;
import org.apache.tika.mime.MimeTypesFactory;
//OODT imports
import org.apache.oodt.commons.xml.XMLUtils;
import org.apache.oodt.product.handlers.ofsn.metadata.OFSNMetKeys;
import org.apache.oodt.product.handlers.ofsn.metadata.OFSNXMLConfigMetKeys;
import org.apache.oodt.product.handlers.ofsn.metadata.OFSNXMLMetKeys;
import org.apache.oodt.product.handlers.ofsn.metadata.XMLQueryMetKeys;
import org.apache.oodt.product.handlers.ofsn.util.OFSNObjectFactory;
import org.apache.oodt.product.handlers.ofsn.util.OFSNUtils;
import org.apache.oodt.product.LargeProductQueryHandler;
import org.apache.oodt.product.ProductException;
import org.apache.oodt.xmlquery.LargeResult;
import org.apache.oodt.xmlquery.Result;
import org.apache.oodt.xmlquery.XMLQuery;
/**
*
* An extensible implementation of the PDS-inspired Online File Specification
* Name (OFSN) style product server. See the ofsn-ps.xml file for a detailed
* specification of the configuration and motivation behind this product
* handler.
*
* @author mattmann
* @version $Revision$
*/
public class OFSNFileHandler implements LargeProductQueryHandler,
XMLQueryMetKeys, OFSNXMLMetKeys, OFSNMetKeys, OFSNXMLConfigMetKeys {
private static final Logger LOG = Logger.getLogger(OFSNFileHandler.class
.getName());
private static final String CMD_SEPARATOR = ";";
// by default return dir size on listing commands
private boolean computeDirSize = true;
// by default return file size on listing commands
private boolean computeFileSize = true;
private OFSNFileHandlerConfiguration conf;
private static Map<String, Object> HANDLER_CACHE;
public OFSNFileHandler() throws InstantiationException {
// init conf here
String xmlConfigFilePath = System.getProperty(OFSN_XML_CONF_FILE_KEY);
this.computeDirSize = Boolean.getBoolean(OFSN_COMPUTE_DIR_SIZE);
this.computeFileSize = Boolean.getBoolean(OFSN_COMPUTE_FILE_SIZE);
if (xmlConfigFilePath == null) {
throw new InstantiationException(
"Must define xml configuration file path via property : ["
+ OFSN_XML_CONF_FILE_KEY + "]");
}
try {
this.conf = OFSNFileHandlerConfigurationReader
.getConfig(xmlConfigFilePath);
} catch (FileNotFoundException e) {
throw new InstantiationException("xml configuration file: ["
+ xmlConfigFilePath + "] not found!");
}
if (this.conf.getProductRoot() == null) {
throw new InstantiationException(
"Must define: [productRoot] attribute in XML configuration!");
}
// used to cache handlers -- map of RT type to Get/List handler instance
HANDLER_CACHE = new HashMap<String, Object>();
}
/*
* (non-Javadoc)
*
* @see org.apache.oodt.product.QueryHandler#query(org.apache.oodt.xmlquery.XMLQuery)
*/
public XMLQuery query(XMLQuery xmlQuery) throws ProductException {
String ofsn = OFSNUtils.extractFieldFromQuery(xmlQuery, OFSN);
String cmd = OFSNUtils.extractFieldFromQuery(xmlQuery, RETURN_TYPE);
validate(ofsn, cmd);
String cmdId = ofsn + CMD_SEPARATOR + cmd;
OFSNHandlerConfig cfg = this.conf.getHandlerConfig(cmd);
validateHandlerConfig(cfg, cmd);
String realPath = this.conf.getProductRoot() + ofsn;
if (isListingCmd(cmd)) {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
OFSNListHandler handler = getListHandler(cmd, cfg.getClassName());
File[] fileList = handler.getListing(realPath);
generateOFSNXml(fileList, cfg, outStream);
xmlQuery.getResults().add(
new Result(cmdId, XML_MIME_TYPE, null, cmdId, Collections.EMPTY_LIST,
outStream.toString()));
} else if (isGetCmd(cmd)) {
OFSNGetHandler handler = getGetHandler(cmd, cfg.getClassName());
String rtAndPath = cmd + CMD_SEPARATOR + realPath;
String mimeType;
// check for and use mimetype conf property if available
if (cfg.getHandlerConf().containsKey(PROPERTY_MIMETYPE_ATTR)) {
MediaType mediaType = MediaType.parse(cfg.getHandlerConf()
.getProperty(PROPERTY_MIMETYPE_ATTR));
if (mediaType == null) {
LOG.log(Level.WARNING, "MIME type ["
+cfg.getHandlerConf().getProperty(PROPERTY_MIMETYPE_ATTR)+"] specified "
+"for handler ["+cfg.getClassName()+"] invalid. Defaulting to MIME type ["
+MediaType.OCTET_STREAM.toString()+"]");
mediaType = MediaType.OCTET_STREAM;
}
mimeType = mediaType.toString();
} else { // use default mimetype of product on disk
mimeType = MimeTypesFactory.create().getMimeType(new File(realPath)).getName();
}
xmlQuery.getResults().add(
new LargeResult(/* id */rtAndPath,/* mimeType */ mimeType, /* profileID */null,
/* resourceID */new File(realPath).getName(), Collections.EMPTY_LIST,
handler.sizeOf(realPath)));
} else {
throw new ProductException("return type: [" + cmd + "] is unsupported!");
}
return xmlQuery;
}
/*
* (non-Javadoc)
*
* @see org.apache.oodt.product.LargeProductQueryHandler#close(java.lang.String)
*/
public void close(String id) throws ProductException {
// nothing to do
}
/*
* (non-Javadoc)
*
* @see
* org.apache.oodt.product.LargeProductQueryHandler#retrieveChunk(java.lang.String,
* long, int)
*/
public byte[] retrieveChunk(String id, long offset, int length)
throws ProductException {
// unmarshall the return type and path
String[] rtTypeAndPathArr = id.split(CMD_SEPARATOR);
String rtType = rtTypeAndPathArr[0];
String filepath = rtTypeAndPathArr[1];
OFSNGetHandler handler = getGetHandler(rtType, this.conf
.getHandlerClass(rtType));
return handler.retrieveChunk(filepath, offset, length);
}
private void generateOFSNXml(File[] mlsFileList, OFSNHandlerConfig cfg,
OutputStream outStream) {
XMLUtils.writeXmlToStream(OFSNUtils.getOFSNDoc(Arrays.asList(mlsFileList),
cfg, this.conf.getProductRoot(), this.computeDirSize, this.computeFileSize),
outStream);
}
private void validate(String ofsn, String cmd) throws ProductException {
if (ofsn == null || cmd == null || (ofsn != null && ofsn.equals(""))
|| (cmd != null && cmd.equals(""))) {
throw new ProductException("must specify OFSN and RT parameters!");
} else if (!OFSNUtils.validateOFSN(ofsn)) {
throw new ProductException("OFSN is invalid");
}
}
private void validateHandlerConfig(OFSNHandlerConfig cfg, String cmd)
throws ProductException {
if (cfg == null) {
throw new ProductException("Unrecognized command: [" + cmd + "]!");
}
}
private OFSNListHandler getListHandler(String rtType, String className) {
if (HANDLER_CACHE.containsKey(rtType)) {
return (OFSNListHandler) HANDLER_CACHE.get(rtType);
} else {
OFSNListHandler handler = OFSNObjectFactory.getListHandler(className);
LOG.log(Level.INFO, "Getting handler config for RT: ["+rtType+"]");
handler.configure(this.conf.getHandlerConfig(rtType).getHandlerConf());
HANDLER_CACHE.put(rtType, handler);
return handler;
}
}
private OFSNGetHandler getGetHandler(String rtType, String className) {
if (HANDLER_CACHE.containsKey(rtType)) {
return (OFSNGetHandler) HANDLER_CACHE.get(rtType);
} else {
OFSNGetHandler handler = OFSNObjectFactory.getGetHandler(className);
handler.configure(this.conf.getHandlerConfig(rtType).getHandlerConf());
HANDLER_CACHE.put(rtType, handler);
return handler;
}
}
private boolean isListingCmd(String cmd) throws ProductException {
OFSNHandlerConfig cfg = this.conf.getHandlerConfig(cmd);
if (cfg == null) {
throw new ProductException("Unrecognized command: [" + cmd + "]!");
}
if (cfg.getType().equals(LISTING_CMD)) {
return true;
} else
return false;
}
private boolean isGetCmd(String cmd) throws ProductException {
OFSNHandlerConfig cfg = this.conf.getHandlerConfig(cmd);
if (cfg.getType().equals(GET_CMD)) {
return true;
} else
return false;
}
}