CatalogContentPlugin.java

/**
 * Copyright (c) Codice Foundation
 * <p/>
 * This is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser
 * General Public License as published by the Free Software Foundation, either version 3 of the
 * License, or any later version.
 * <p/>
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details. A copy of the GNU Lesser General Public License
 * is distributed along with this program and can be found at
 * <http://www.gnu.org/licenses/lgpl.html>.
 */
package ddf.content.plugin.cataloger;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;

import javax.activation.MimeType;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.LoggerFactory;
import org.slf4j.ext.XLogger;

import com.google.common.io.FileBackedOutputStream;

import ddf.catalog.CatalogFramework;
import ddf.catalog.data.BinaryContent;
import ddf.catalog.data.Metacard;
import ddf.catalog.data.MetacardCreationException;
import ddf.catalog.data.impl.AttributeImpl;
import ddf.catalog.transform.CatalogTransformerException;
import ddf.catalog.transform.InputTransformer;
import ddf.content.data.ContentItem;
import ddf.content.operation.CreateResponse;
import ddf.content.operation.DeleteResponse;
import ddf.content.operation.UpdateResponse;
import ddf.content.operation.impl.CreateResponseImpl;
import ddf.content.operation.impl.DeleteResponseImpl;
import ddf.content.operation.impl.UpdateResponseImpl;
import ddf.content.plugin.ContentPlugin;
import ddf.content.plugin.PluginExecutionException;
import ddf.mime.MimeTypeToTransformerMapper;
import ddf.security.SubjectUtils;

public class CatalogContentPlugin implements ContentPlugin {
    private static final XLogger LOGGER = new XLogger(
            LoggerFactory.getLogger(CatalogContentPlugin.class));

    private static final String CATALOG_ID = "Catalog-ID";

    private static final String DEFAULT_METACARD_TRANSFORMER = "geojson";

    private final CatalogFramework catalogFramework;

    private Cataloger cataloger;

    private MimeTypeToTransformerMapper mimeTypeToTransformerMapper;

    public CatalogContentPlugin(CatalogFramework catalogFramework,
            MimeTypeToTransformerMapper mimeTypeToTransformerMapper) {
        LOGGER.trace("INSIDE: CatalogContentPlugin constructor");

        this.catalogFramework = catalogFramework;
        this.cataloger = new Cataloger(catalogFramework);
        this.mimeTypeToTransformerMapper = mimeTypeToTransformerMapper;
    }

    @Override
    public CreateResponse process(CreateResponse input) throws PluginExecutionException {
        LOGGER.trace("ENTERING: process(CreateResponse)");

        ContentItem createdContentItem = input.getCreatedContentItem();
        CreateResponseImpl response = new CreateResponseImpl(input);
        MimeType mimeType = createdContentItem.getMimeType();
        InputStream stream = null;
        try {
            stream = createdContentItem.getInputStream();
        } catch (IOException e) {
            throw new PluginExecutionException(
                    "Unable to read InputStream in created content item.", e);
        }

        if (stream == null) {
            throw new PluginExecutionException("InputStream is null in created content item.");
        }

        try {
            Metacard metacard = generateMetacard(createdContentItem, mimeType,
                    createdContentItem.getUri(), stream);
            String catalogId = cataloger.createMetacard(metacard);
            LOGGER.debug("catalogId = " + catalogId);
            Map<String, String> properties = response.getResponseProperties();
            properties.put(CATALOG_ID, catalogId);
            response.setResponseProperties(properties);
            if (metacard != null) {
                try {
                    BinaryContent binaryContent = catalogFramework
                            .transform(metacard, DEFAULT_METACARD_TRANSFORMER, null);
                    response.setCreatedMetadata(binaryContent.getByteArray());
                    response.setCreatedMetadataMimeType(binaryContent.getMimeType().toString());
                } catch (IOException | CatalogTransformerException e) {
                    LOGGER.warn("Unable to transform metacard to readable metadata.", e);
                }
            }
        } catch (MetacardCreationException e) {
            LOGGER.warn(e.getMessage(), e);
            throw new PluginExecutionException(e.getMessage(), e);
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) {
                }
            }
        }

        LOGGER.trace("EXITING: process(CreateResponse)");

        return response;
    }

    @Override
    public UpdateResponse process(UpdateResponse input) throws PluginExecutionException {
        LOGGER.trace("ENTERING: process(UpdateResponse)");

        ContentItem updatedContentItem = input.getUpdatedContentItem();
        UpdateResponseImpl response = new UpdateResponseImpl(input);
        MimeType mimeType = updatedContentItem.getMimeType();
        InputStream stream = null;
        try {
            stream = updatedContentItem.getInputStream();
        } catch (IOException e) {
            throw new PluginExecutionException(
                    "Unable to read InputStream in updated content item.", e);
        }

        if (stream == null) {
            throw new PluginExecutionException("InputStream is null in updated content item.");
        }

        try {
            Metacard metacard = generateMetacard(updatedContentItem, mimeType,
                    updatedContentItem.getUri(), stream);
            String catalogId = cataloger.updateMetacard(updatedContentItem.getUri(), metacard);
            LOGGER.debug("catalogId = " + catalogId);
            Map<String, String> properties = response.getResponseProperties();
            properties.put(CATALOG_ID, catalogId);
            response.setResponseProperties(properties);
            if (metacard != null) {
                try {
                    BinaryContent binaryContent = catalogFramework
                            .transform(metacard, DEFAULT_METACARD_TRANSFORMER, null);
                    response.setUpdatedMetadata(binaryContent.getByteArray());
                    response.setUpdatedMetadataMimeType(binaryContent.getMimeType().toString());
                } catch (IOException | CatalogTransformerException e) {
                    LOGGER.warn("Unable to transform metacard to readable metadata.", e);
                }
            }
        } catch (MetacardCreationException e) {
            LOGGER.warn(e.getMessage(), e);
            throw new PluginExecutionException(e.getMessage(), e);
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) {
                }
            }
        }

        LOGGER.trace("EXITING: process(UpdateResponse)");

        return response;
    }

    @Override
    public DeleteResponse process(DeleteResponse input) throws PluginExecutionException {
        LOGGER.trace("ENTERING: process(DeleteResponse)");

        DeleteResponseImpl response = new DeleteResponseImpl(input);

        String catalogId = cataloger.deleteMetacard(input.getContentItem().getUri());
        if (catalogId != null && !catalogId.isEmpty()) {
            // Create response indicating file (actually, catalog entry) was deleted
            response = new DeleteResponseImpl(input.getRequest(), input.getContentItem(), true,
                    input.getResponseProperties(), input.getProperties());
        }

        LOGGER.debug("catalogId = " + catalogId);
        Map<String, String> properties = response.getResponseProperties();
        properties.put(CATALOG_ID, catalogId);
        response.setResponseProperties(properties);

        LOGGER.trace("EXITING: process(DeleteResponse)");

        return response;
    }

    private Metacard generateMetacard(ContentItem contentItem, MimeType mimeType, String uri,
            InputStream message) throws MetacardCreationException {
        LOGGER.trace("ENTERING: generateMetacard");

        List<InputTransformer> listOfCandidates = mimeTypeToTransformerMapper
                .findMatches(InputTransformer.class, mimeType);

        LOGGER.debug("List of matches for mimeType [ {} ]: {}", mimeType, listOfCandidates);

        Metacard generatedMetacard = null;
        try (FileBackedOutputStream fileBackedOutputStream = new FileBackedOutputStream(1000000)) {

            long size;
            try {
                size = IOUtils.copyLarge(message, fileBackedOutputStream);
                LOGGER.debug("Copied {} bytes of file in content framework", size);
            } catch (IOException e) {
                throw new MetacardCreationException("Could not copy bytes of content message.", e);
            }

            // Multiple InputTransformers may be found that match the mime type.
            // Need to try each InputTransformer until we find one that can successfully transform
            // the input stream's data into a metacard. Once an InputTransformer is found that
            // can create the metacard, then do not need to try any remaining InputTransformers.
            for (InputTransformer transformer : listOfCandidates) {

                try (InputStream inputStreamMessageCopy = fileBackedOutputStream.asByteSource()
                        .openStream()) {
                    generatedMetacard = transformer.transform(inputStreamMessageCopy);
                    if (generatedMetacard != null) {
                        try {
                            Subject subject = SecurityUtils.getSubject();
                            if (subject != null) {
                                generatedMetacard.setAttribute(
                                        new AttributeImpl(Metacard.POINT_OF_CONTACT,
                                                SubjectUtils.getName(subject)));
                            }
                        } catch (IllegalStateException e) {
                            LOGGER.debug("Unable to retrieve user from request.", e);
                        }

                        if (uri != null) {
                            //Setting the non-transformer specific information not including creation and modification dates/times
                            generatedMetacard
                                    .setAttribute(new AttributeImpl(Metacard.RESOURCE_URI, uri));
                            generatedMetacard.setAttribute(new AttributeImpl(Metacard.RESOURCE_SIZE,
                                    String.valueOf(size)));
                        } else {
                            LOGGER.debug("Metacard had a null uri");
                        }
                        if (StringUtils.isBlank(generatedMetacard.getTitle())) {
                            LOGGER.debug("Metacard title was blank. Setting title to filename.");
                            generatedMetacard.setAttribute(
                                    new AttributeImpl(Metacard.TITLE, contentItem.getFilename()));
                        }
                        break;
                    }
                } catch (IOException | CatalogTransformerException e) {
                    LOGGER.debug("Transformer [" + transformer + "] could not create metacard.", e);
                }

            }

            if (generatedMetacard == null) {
                throw new MetacardCreationException(
                        "Could not create metacard with mimeType " + mimeType
                                + ". No valid transformers found.");
            }

            LOGGER.trace("EXITING: generateMetacard");
        } catch (IOException e) {
            LOGGER.debug("Error encountered while using filed backed stream.", e);
        }

        return generatedMetacard;
    }

}