Page History

package org.apache.servicemix.jbi;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.jbi.component.ComponentContext;
import javax.jbi.messaging.MessageExchange;
import javax.jbi.messaging.MessagingException;
import javax.jbi.messaging.NormalizedMessage;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.servicemix.http.endpoints.DefaultHttpConsumerMarshaler;
import org.apache.servicemix.jbi.jaxp.StringSource;
import org.apache.servicemix.jbi.messaging.MessageExchangeSupport;
import org.apache.servicemix.jbi.util.ByteArrayDataSource;
import org.apache.servicemix.jbi.util.FileUtil;
import org.apache.servicemix.jbi.util.StreamDataSource;

public class HTTPMarshaler extends DefaultHttpConsumerMarshaler
{
    private static final Logger logger = Logger.getLogger(HTTPMarshaler.class.getName());
    private static final int MAX_MEM_SIZE = 10 * 1024 * 1024;
    private static final File TEMP_FOLDER = new File(System.getProperty("java.io.tmpdir"));
    private static final long MAX_UPLOAD_SIZE = 1024 * 1024 * 100;

    private DiskFileItemFactory factory;
    private ServletFileUpload upload;

    /** 
     * constructor 
     */
    public HTTPMarshaler()
        {
        super(MessageExchangeSupport.IN_OUT);

        // Create a factory for disk-based file items 
        factory = new DiskFileItemFactory();

        // Set factory constraints 
        factory.setSizeThreshold(MAX_MEM_SIZE);
        factory.setRepository(TEMP_FOLDER);

        // Create a new file upload handler 
        upload = new ServletFileUpload(factory);

        // Set overall request size constraint 
        upload.setSizeMax(MAX_UPLOAD_SIZE);
        }

    public MessageExchange createExchange(HttpServletRequest request, ComponentContext context) throws Exception
        {
        MessageExchange me = context.getDeliveryChannel().createExchangeFactory().createExchange(getDefaultMep());

        // Check that we have a file upload request 
        boolean isMultipart = ServletFileUpload.isMultipartContent(request);

        if (isMultipart)
            {
            NormalizedMessage in = me.createMessage();
            in.setContent(new StringSource("<payload/>"));

            // Parse the request 
            List items = upload.parseRequest(request);

            // Process the uploaded items 
            Iterator iter = items.iterator();
            while (iter.hasNext())
                {
                FileItem item = (FileItem)iter.next();

                if (item.isFormField())
                    {
                    processFormField(item, in);
                    }
                else
                    {
                    processUploadedFile(item, in);
                    }
                }

            me.setMessage(in, "in");
            }
        else
            {
            throw new Exception("Request is not a valid multipart message");
            }

        return me;
        }

    /** 
     * processes form fields 
     * 
     * @param item  the field 
     * @param msg   the in message 
     */
    private void processFormField(FileItem item, NormalizedMessage msg)
        {
        String name = item.getFieldName();
        String value = item.getString();
        msg.setProperty(name, value);
        }

    /** 
     * processes file items 
     * 
     * @param item  the item 
     * @param msg   the in message 
     */
    private void processUploadedFile(FileItem item, NormalizedMessage msg)
        {
        String fieldName = item.getFieldName();
        String fileName = item.getName();
        String contentType = item.getContentType();
        boolean isInMemory = item.isInMemory();
        long sizeInBytes = item.getSize();

        DataHandler dh = null;

        if (isInMemory)
            {
            dh = new DataHandler(new ByteArrayDataSource(item.get(), item.getContentType()));
            }
        else
            {
            try
                {
                dh = new DataHandler(new StreamDataSource(item.getInputStream(), item.getContentType()));
                }
            catch (IOException ioex)
                {
                dh = new DataHandler(new ByteArrayDataSource(item.get(), item.getContentType()));
                }
            }

        try
            {
            msg.addAttachment(fileName, dh);
            }
        catch (MessagingException e)
            {
            e.printStackTrace();
            }
        }

    public void sendOut(MessageExchange exchange, NormalizedMessage outMsg, HttpServletRequest request,
            HttpServletResponse response) throws Exception
        {
        DataHandler dh = null;

        if (outMsg.getAttachmentNames().isEmpty())
            {
            sendError(exchange, new Exception("Invalid answer from handler."), request, response);
            return;
            }

        Set set = outMsg.getAttachmentNames();
        Iterator iterator = set.iterator();
        String key = null;
        if (iterator.hasNext())
            {
            key = iterator.next().toString();
            dh = outMsg.getAttachment(key);
            }
        else
            {
            sendError(exchange, new Exception("Invalid answer from handler."), request, response);
            return;
            }

        if (dh == null)
            {
            sendError(exchange, new Exception("Invalid answer from handler."), request, response);
            return;
            }

        File f = File.createTempFile("tmp_", key);
        FileOutputStream fos = new FileOutputStream(f);

        FileUtil.copyInputStream(dh.getDataSource().getInputStream(), fos);
        fos.close();

        FileDataSource fds = new FileDataSource(f);
        StreamDataSource sds = new StreamDataSource(fds.getInputStream(), fds.getContentType());
        DataHandler dhsds = new DataHandler(sds);

        response.setHeader("content-disposition", "attachment; filename=\"" + key + "\"");
        response.setContentType(fds.getContentType());
        response.setContentLength((int)f.length());
        try
            {
            ServletOutputStream sos = response.getOutputStream();
            dhsds.writeTo(sos);
            response.setStatus(HttpServletResponse.SC_OK);
            }
        catch (Exception e)
            {
            logger.log(Level.WARNING, "Exception occurred" + e.getMessage(), e);
            }
        f.deleteOnExit();
        }
}