Example usage for org.apache.commons.fileupload FileUpload parseRequest

List of usage examples for org.apache.commons.fileupload FileUpload parseRequest

Introduction

In this page you can find the example usage for org.apache.commons.fileupload FileUpload parseRequest.

Prototype

public List  parseRequest(HttpServletRequest req) throws FileUploadException 

Source Link

Document

Processes an <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant <code>multipart/form-data</code> stream.

Usage

From source file:edu.ucsb.eucalyptus.transport.query.WalrusQueryDispatcher.java

public String getOperation(HttpRequest httpRequest, MessageContext messageContext)
        throws EucalyptusCloudException {
    //Figure out if it is an operation on the service, a bucket or an object
    Map operationParams = new HashMap();
    String[] target = null;/*w  w  w  .ja  v a  2 s  .  c om*/
    String path = httpRequest.getOperationPath();
    boolean walrusInternalOperation = false;
    if (path.length() > 0) {
        target = getTarget(path);
    }

    String verb = httpRequest.getHttpMethod();
    Map<String, String> headers = httpRequest.getHeaders();
    CaseInsensitiveMap caseInsensitiveHeaders = new CaseInsensitiveMap(headers);
    String operationKey = "";
    Map<String, String> params = httpRequest.getParameters();
    String operationName = null;
    long contentLength = 0;
    String contentLengthString = (String) messageContext.getProperty(HTTP.CONTENT_LEN);
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
    }
    if (caseInsensitiveHeaders.containsKey(StorageProperties.EUCALYPTUS_OPERATION)) {
        String value = caseInsensitiveHeaders.get(StorageProperties.EUCALYPTUS_OPERATION);
        for (WalrusProperties.WalrusInternalOperations operation : WalrusProperties.WalrusInternalOperations
                .values()) {
            if (value.toLowerCase().equals(operation.toString().toLowerCase())) {
                operationName = operation.toString();
                walrusInternalOperation = true;
                break;
            }
        }

        if (!walrusInternalOperation) {
            for (WalrusProperties.StorageOperations operation : WalrusProperties.StorageOperations.values()) {
                if (value.toLowerCase().equals(operation.toString().toLowerCase())) {
                    operationName = operation.toString();
                    walrusInternalOperation = true;
                    break;
                }
            }
        }

    }

    if (target == null) {
        //target = service
        operationKey = SERVICE + verb;
    } else if (target.length < 2) {
        //target = bucket
        if (!target[0].equals("")) {
            operationKey = BUCKET + verb;
            operationParams.put("Bucket", target[0]);

            if (verb.equals(HTTPVerb.POST.toString())) {
                InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_PUT, Boolean.TRUE);
                String contentType = caseInsensitiveHeaders.get(HTTP.CONTENT_TYPE);
                int postContentLength = Integer.parseInt(caseInsensitiveHeaders.get(HTTP.CONTENT_LEN));
                POSTRequestContext postRequestContext = new POSTRequestContext(in, contentType,
                        postContentLength);
                FileUpload fileUpload = new FileUpload(new WalrusFileItemFactory());
                InputStream formDataIn = null;
                String objectKey = null;
                String file = "";
                String key;
                Map<String, String> formFields = new HashMap<String, String>();
                try {
                    List<FileItem> parts = fileUpload.parseRequest(postRequestContext);
                    for (FileItem part : parts) {
                        if (part.isFormField()) {
                            String fieldName = part.getFieldName().toString().toLowerCase();
                            InputStream formFieldIn = part.getInputStream();
                            int bytesRead;
                            String fieldValue = "";
                            byte[] bytes = new byte[512];
                            while ((bytesRead = formFieldIn.read(bytes)) > 0) {
                                fieldValue += new String(bytes, 0, bytesRead);
                            }
                            formFields.put(fieldName, fieldValue);
                        } else {
                            formDataIn = part.getInputStream();
                            if (part.getName() != null)
                                file = part.getName();
                        }
                    }
                } catch (Exception ex) {
                    LOG.warn(ex, ex);
                    throw new EucalyptusCloudException("could not process form request");
                }

                String authenticationHeader = "";
                formFields.put(WalrusProperties.FormField.bucket.toString(), target[0]);
                if (formFields.containsKey(WalrusProperties.FormField.key.toString())) {
                    objectKey = formFields.get(WalrusProperties.FormField.key.toString());
                    objectKey = objectKey.replaceAll("\\$\\{filename\\}", file);
                }
                if (formFields.containsKey(WalrusProperties.FormField.acl.toString())) {
                    String acl = formFields.get(WalrusProperties.FormField.acl.toString());
                    headers.put(WalrusProperties.AMZ_ACL, acl);
                }
                if (formFields.containsKey(WalrusProperties.FormField.success_action_redirect.toString())) {
                    String successActionRedirect = formFields
                            .get(WalrusProperties.FormField.success_action_redirect.toString());
                    operationParams.put("SuccessActionRedirect", successActionRedirect);
                }
                if (formFields.containsKey(WalrusProperties.FormField.success_action_status.toString())) {
                    Integer successActionStatus = Integer.parseInt(
                            formFields.get(WalrusProperties.FormField.success_action_status.toString()));
                    if (successActionStatus == 200 || successActionStatus == 201)
                        operationParams.put("SuccessActionStatus", successActionStatus);
                    else
                        operationParams.put("SuccessActionStatus", 204);
                } else {
                    operationParams.put("SuccessActionStatus", 204);
                }
                if (formFields.containsKey(WalrusProperties.FormField.policy.toString())) {
                    String policy = new String(
                            Base64.decode(formFields.remove(WalrusProperties.FormField.policy.toString())));
                    String policyData;
                    try {
                        policyData = new String(Base64.encode(policy.getBytes()));
                    } catch (Exception ex) {
                        LOG.warn(ex, ex);
                        throw new EucalyptusCloudException("error reading policy data.");
                    }
                    //parse policy
                    try {
                        JSONObject policyObject = new JSONObject(policy);
                        String expiration = (String) policyObject
                                .get(WalrusProperties.PolicyHeaders.expiration.toString());
                        if (expiration != null) {
                            Date expirationDate = DateUtils.parseIso8601DateTimeOrDate(expiration);
                            if ((new Date()).getTime() > expirationDate.getTime()) {
                                LOG.warn("Policy has expired.");
                                //TODO: currently this will be reported as an invalid operation
                                //Fix this to report a security exception
                                throw new EucalyptusCloudException("Policy has expired.");
                            }
                        }
                        List<String> policyItemNames = new ArrayList<String>();

                        JSONArray conditions = (JSONArray) policyObject
                                .get(WalrusProperties.PolicyHeaders.conditions.toString());
                        for (int i = 0; i < conditions.length(); ++i) {
                            Object policyItem = conditions.get(i);
                            if (policyItem instanceof JSONObject) {
                                JSONObject jsonObject = (JSONObject) policyItem;
                                if (!exactMatch(jsonObject, formFields, policyItemNames)) {
                                    LOG.warn("Policy verification failed. ");
                                    throw new EucalyptusCloudException("Policy verification failed.");
                                }
                            } else if (policyItem instanceof JSONArray) {
                                JSONArray jsonArray = (JSONArray) policyItem;
                                if (!partialMatch(jsonArray, formFields, policyItemNames)) {
                                    LOG.warn("Policy verification failed. ");
                                    throw new EucalyptusCloudException("Policy verification failed.");
                                }
                            }
                        }

                        Set<String> formFieldsKeys = formFields.keySet();
                        for (String formKey : formFieldsKeys) {
                            if (formKey.startsWith(WalrusProperties.IGNORE_PREFIX))
                                continue;
                            boolean fieldOkay = false;
                            for (WalrusProperties.IgnoredFields field : WalrusProperties.IgnoredFields
                                    .values()) {
                                if (formKey.equals(field.toString().toLowerCase())) {
                                    fieldOkay = true;
                                    break;
                                }
                            }
                            if (fieldOkay)
                                continue;
                            if (policyItemNames.contains(formKey))
                                continue;
                            LOG.warn("All fields except those marked with x-ignore- should be in policy.");
                            throw new EucalyptusCloudException(
                                    "All fields except those marked with x-ignore- should be in policy.");
                        }
                    } catch (Exception ex) {
                        //rethrow
                        if (ex instanceof EucalyptusCloudException)
                            throw (EucalyptusCloudException) ex;
                        LOG.warn(ex);
                    }
                    //all form uploads without a policy are anonymous
                    if (formFields
                            .containsKey(WalrusProperties.FormField.AWSAccessKeyId.toString().toLowerCase())) {
                        String accessKeyId = formFields
                                .remove(WalrusProperties.FormField.AWSAccessKeyId.toString().toLowerCase());
                        authenticationHeader += "AWS" + " " + accessKeyId + ":";
                    }
                    if (formFields.containsKey(WalrusProperties.FormField.signature.toString())) {
                        String signature = formFields.remove(WalrusProperties.FormField.signature.toString());
                        authenticationHeader += signature;
                        headers.put(HMACQuerySecurityHandler.SecurityParameter.Authorization.toString(),
                                authenticationHeader);
                    }
                    headers.put(WalrusProperties.FormField.FormUploadPolicyData.toString(), policyData);
                }
                operationParams.put("Key", objectKey);
                key = target[0] + "." + objectKey;
                String randomKey = key + "." + Hashes.getRandom(10);
                LinkedBlockingQueue<WalrusDataMessage> putQueue = getWriteMessenger()
                        .interruptAllAndGetQueue(key, randomKey);

                Writer writer = new Writer(formDataIn, postContentLength, putQueue);
                writer.start();

                operationParams.put("ContentLength", (new Long(postContentLength).toString()));
                operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);
            }

        } else {
            operationKey = SERVICE + verb;
        }
    } else {
        //target = object
        operationKey = OBJECT + verb;
        String objectKey = "";
        String splitOn = "";
        for (int i = 1; i < target.length; ++i) {
            objectKey += splitOn + target[i];
            splitOn = "/";
        }
        operationParams.put("Bucket", target[0]);
        operationParams.put("Key", objectKey);

        if (!params.containsKey(OperationParameter.acl.toString())) {
            if (verb.equals(HTTPVerb.PUT.toString())) {
                if (caseInsensitiveHeaders.containsKey(WalrusProperties.COPY_SOURCE.toString())) {
                    String copySource = caseInsensitiveHeaders.get(WalrusProperties.COPY_SOURCE.toString());
                    String[] sourceTarget = getTarget(copySource);
                    String sourceObjectKey = "";
                    String sourceSplitOn = "";
                    if (sourceTarget.length > 1) {
                        for (int i = 1; i < sourceTarget.length; ++i) {
                            sourceObjectKey += sourceSplitOn + sourceTarget[i];
                            sourceSplitOn = "/";
                        }
                        operationParams.put("SourceBucket", sourceTarget[0]);
                        operationParams.put("SourceObject", sourceObjectKey);
                        operationParams.put("DestinationBucket", operationParams.remove("Bucket"));
                        operationParams.put("DestinationObject", operationParams.remove("Key"));

                        String metaDataDirective = caseInsensitiveHeaders
                                .get(WalrusProperties.METADATA_DIRECTIVE.toString());
                        if (metaDataDirective != null) {
                            operationParams.put("MetadataDirective", metaDataDirective);
                        }
                        AccessControlListType accessControlList;
                        if (contentLength > 0) {
                            InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                            accessControlList = getAccessControlList(in);
                        } else {
                            accessControlList = new AccessControlListType();
                        }
                        operationParams.put("AccessControlList", accessControlList);
                        operationKey += WalrusProperties.COPY_SOURCE.toString();
                        Iterator<String> iterator = caseInsensitiveHeaders.keySet().iterator();
                        while (iterator.hasNext()) {
                            String key = iterator.next();
                            for (WalrusProperties.CopyHeaders header : WalrusProperties.CopyHeaders.values()) {
                                if (key.replaceAll("-", "").equals(header.toString().toLowerCase())) {
                                    String value = caseInsensitiveHeaders.get(key);
                                    parseExtendedHeaders(operationParams, header.toString(), value);
                                }
                            }
                        }
                    } else {
                        throw new EucalyptusCloudException("Malformed COPY request");
                    }

                } else {
                    messageContext.setProperty(WalrusProperties.STREAMING_HTTP_PUT, Boolean.TRUE);
                    InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                    InputStream inStream = in;
                    if ((!walrusInternalOperation) || (!WalrusProperties.StorageOperations.StoreSnapshot
                            .toString().equals(operationName))) {
                        inStream = new BufferedInputStream(in);
                    } else {
                        try {
                            inStream = new GZIPInputStream(in);
                        } catch (Exception ex) {
                            LOG.warn(ex, ex);
                            throw new EucalyptusCloudException("cannot process input");
                        }
                    }
                    String key = target[0] + "." + objectKey;
                    String randomKey = key + "." + Hashes.getRandom(10);
                    LinkedBlockingQueue<WalrusDataMessage> putQueue = getWriteMessenger()
                            .interruptAllAndGetQueue(key, randomKey);

                    Writer writer = new Writer(inStream, contentLength, putQueue);
                    writer.start();

                    operationParams.put("ContentLength", (new Long(contentLength).toString()));
                    operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);
                }
            } else if (verb.equals(HTTPVerb.GET.toString())) {
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_GET, Boolean.TRUE);
                if (!walrusInternalOperation) {

                    operationParams.put("GetData", Boolean.TRUE);
                    operationParams.put("InlineData", Boolean.FALSE);
                    operationParams.put("GetMetaData", Boolean.TRUE);

                    Iterator<String> iterator = caseInsensitiveHeaders.keySet().iterator();
                    boolean isExtendedGet = false;
                    while (iterator.hasNext()) {
                        String key = iterator.next();
                        for (WalrusProperties.ExtendedGetHeaders header : WalrusProperties.ExtendedGetHeaders
                                .values()) {
                            if (key.replaceAll("-", "").equals(header.toString().toLowerCase())) {
                                String value = caseInsensitiveHeaders.get(key);
                                isExtendedGet = true;
                                parseExtendedHeaders(operationParams, header.toString(), value);
                            }
                        }

                    }
                    if (isExtendedGet) {
                        operationKey += "extended";
                        //only supported through SOAP
                        operationParams.put("ReturnCompleteObjectOnConditionFailure", Boolean.FALSE);
                    }
                } else {
                    for (WalrusProperties.InfoOperations operation : WalrusProperties.InfoOperations.values()) {
                        if (operation.toString().equals(operationName)) {
                            messageContext.removeProperty(WalrusProperties.STREAMING_HTTP_GET);
                            break;
                        }
                    }
                }
                if (params.containsKey(WalrusProperties.GetOptionalParameters.IsCompressed.toString())) {
                    Boolean isCompressed = Boolean.parseBoolean(
                            params.remove(WalrusProperties.GetOptionalParameters.IsCompressed.toString()));
                    operationParams.put("IsCompressed", isCompressed);
                }

            } else if (verb.equals(HTTPVerb.HEAD.toString())) {
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_GET, Boolean.FALSE);
                if (!walrusInternalOperation) {
                    operationParams.put("GetData", Boolean.FALSE);
                    operationParams.put("InlineData", Boolean.FALSE);
                    operationParams.put("GetMetaData", Boolean.TRUE);
                }
            }
        }

    }

    if (verb.equals(HTTPVerb.PUT.toString()) && params.containsKey(OperationParameter.acl.toString())) {
        //read ACL
        InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
        operationParams.put("AccessControlPolicy", getAccessControlPolicy(in));
    }

    ArrayList paramsToRemove = new ArrayList();

    boolean addMore = true;
    Iterator iterator = params.keySet().iterator();
    while (iterator.hasNext()) {
        Object key = iterator.next();
        String keyString = key.toString().toLowerCase();
        boolean dontIncludeParam = false;
        for (HMACQuerySecurityHandler.SecurityParameter securityParam : HMACQuerySecurityHandler.SecurityParameter
                .values()) {
            if (keyString.equals(securityParam.toString().toLowerCase())) {
                dontIncludeParam = true;
                break;
            }
        }
        if (dontIncludeParam)
            continue;
        String value = params.get(key);
        if (value != null) {
            String[] keyStringParts = keyString.split("-");
            if (keyStringParts.length > 1) {
                keyString = "";
                for (int i = 0; i < keyStringParts.length; ++i) {
                    keyString += toUpperFirst(keyStringParts[i]);
                }
            } else {
                keyString = toUpperFirst(keyString);
            }
            operationParams.put(keyString, value);
        }
        if (addMore) {
            //just add the first one to the key
            operationKey += keyString.toLowerCase();
            addMore = false;
        }
        paramsToRemove.add(key);
    }

    for (Object key : paramsToRemove) {
        params.remove(key);
    }

    if (!walrusInternalOperation) {
        operationName = operationMap.get(operationKey);
    }
    httpRequest.setBindingArguments(operationParams);
    messageContext.setProperty(WalrusProperties.WALRUS_OPERATION, operationName);
    return operationName;
}

From source file:axiom.servlet.AbstractServletClient.java

protected List parseUploads(ServletRequestContext reqcx, RequestTrans reqtrans, final UploadStatus uploadStatus,
        String encoding) throws FileUploadException, UnsupportedEncodingException {

    List uploads = null;/*  w w w.j a  va  2s.  c  om*/
    Context cx = Context.enter();
    ImporterTopLevel scope = new ImporterTopLevel(cx, true);

    try {
        // handle file upload
        DiskFileItemFactory factory = new DiskFileItemFactory();
        FileUpload upload = new FileUpload(factory);
        // use upload limit for individual file size, but also set a limit on overall size
        upload.setFileSizeMax(uploadLimit * 1024);
        upload.setSizeMax(totalUploadLimit * 1024);

        // register upload tracker with user's session
        if (uploadStatus != null) {
            upload.setProgressListener(new ProgressListener() {
                public void update(long bytesRead, long contentLength, int itemsRead) {
                    uploadStatus.update(bytesRead, contentLength, itemsRead);
                }
            });
        }

        uploads = upload.parseRequest(reqcx);
        Iterator it = uploads.iterator();

        while (it.hasNext()) {
            FileItem item = (FileItem) it.next();
            String name = item.getFieldName();
            Object value = null;
            // check if this is an ordinary HTML form element or a file upload
            if (item.isFormField()) {
                value = item.getString(encoding);
            } else {
                String itemName = item.getName().trim();
                if (itemName == null || itemName.equals("")) {
                    continue;
                }
                value = new MimePart(itemName, item.get(), item.getContentType());
                value = new NativeJavaObject(scope, value, value.getClass());
            }
            item.delete();
            // if multiple values exist for this name, append to _array

            // reqtrans.addPostParam(name, value); ????

            Object ret = reqtrans.get(name);
            if (ret != null && ret != Scriptable.NOT_FOUND) {
                appendFormValue(reqtrans, name, value);
            } else {
                reqtrans.set(name, value);
            }
        }
    } finally {
        Context.exit();
    }

    return uploads;
}

From source file:org.etk.core.rest.impl.provider.MultipartFormDataEntityProvider.java

/**
 * {@inheritDoc}/*ww  w  . j  a  va 2 s . c o m*/
 */
@SuppressWarnings("unchecked")
public Iterator<FileItem> readFrom(Class<Iterator<FileItem>> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
        throws IOException {
    try {
        ApplicationContext context = ApplicationContextImpl.getCurrent();
        int bufferSize = (Integer) context.getAttributes().get(RequestHandler.WS_RS_BUFFER_SIZE);
        File repo = (File) context.getAttributes().get(RequestHandler.WS_RS_TMP_DIR);

        DefaultFileItemFactory factory = new DefaultFileItemFactory(bufferSize, repo);
        FileUpload upload = new FileUpload(factory);
        return upload.parseRequest(httpRequest).iterator();
    } catch (FileUploadException e) {
        throw new IOException("Can't process multipart data item " + e);
    }
}

From source file:org.everrest.core.impl.provider.ext.InMemoryMultipartFormDataEntityProvider.java

@SuppressWarnings("unchecked")
@Override//from  ww w . j a va  2  s. c o m
public Iterator<FileItem> readFrom(Class<Iterator<FileItem>> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
        throws IOException {
    try {
        ApplicationContext context = ApplicationContextImpl.getCurrent();
        int bufferSize = context.getEverrestConfiguration().getMaxBufferSize();
        FileItemFactory factory = new InMemoryItemFactory(bufferSize);
        FileUpload upload = new FileUpload(factory);
        return upload.parseRequest(httpRequest).iterator();
    } catch (FileUploadException e) {
        throw new IOException("Can't process multipart data item " + e);
    }
}

From source file:org.everrest.core.impl.provider.MultipartFormDataEntityProvider.java

@Override
@SuppressWarnings("unchecked")
public Iterator<FileItem> readFrom(Class<Iterator<FileItem>> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
        throws IOException {
    try {/* w  ww  . j  a v a  2s.com*/
        ApplicationContext context = ApplicationContextImpl.getCurrent();
        int bufferSize = context.getEverrestConfiguration().getMaxBufferSize();
        DefaultFileItemFactory factory = new DefaultFileItemFactory(bufferSize,
                FileCollector.getInstance().getStore());
        FileUpload upload = new FileUpload(factory);
        return upload.parseRequest(httpRequest).iterator();
    } catch (FileUploadException e) {
        throw new IOException("Can't process multipart data item " + e);
    }
}

From source file:org.exoplatform.services.rest.impl.provider.MultipartFormDataEntityProvider.java

/**
 * {@inheritDoc}/*w  w w .j  a  v a2s . c om*/
 */
@SuppressWarnings("unchecked")
public Iterator<FileItem> readFrom(Class<Iterator<FileItem>> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
        throws IOException {
    try {
        ApplicationContext context = ApplicationContextImpl.getCurrent();
        int bufferSize = context.getProperties().get(RequestHandler.WS_RS_BUFFER_SIZE) == null
                ? RequestHandler.WS_RS_BUFFER_SIZE_VALUE
                : Integer.parseInt(context.getProperties().get(RequestHandler.WS_RS_BUFFER_SIZE));
        File repo = new File(context.getProperties().get(RequestHandler.WS_RS_TMP_DIR));

        DefaultFileItemFactory factory = new DefaultFileItemFactory(bufferSize, repo);
        final FileUpload upload = new FileUpload(factory);

        return SecurityHelper.doPrivilegedExceptionAction(new PrivilegedExceptionAction<Iterator<FileItem>>() {
            public Iterator<FileItem> run() throws Exception {
                return upload.parseRequest(httpRequest).iterator();
            }
        });
    } catch (PrivilegedActionException pae) {
        Throwable cause = pae.getCause();
        if (cause instanceof FileUploadException) {
            throw new IOException("Can't process multipart data item " + cause, cause);
        } else if (cause instanceof RuntimeException) {
            throw (RuntimeException) cause;
        } else {
            throw new RuntimeException(cause);
        }
    }
}

From source file:org.nuxeo.ecm.platform.ui.web.util.FileUploadHelper.java

/**
 * Parses a Multipart Servlet Request to extract blobs
 *///from w w w.  jav a2 s.  com
public static List<Blob> parseRequest(HttpServletRequest request) throws FileUploadException, IOException {
    List<Blob> blobs = new ArrayList<Blob>();

    if (request instanceof MultipartRequest) {
        MultipartRequest seamMPRequest = (MultipartRequest) request;

        Enumeration<String> names = seamMPRequest.getParameterNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            try (InputStream in = seamMPRequest.getFileInputStream(name)) {
                if (in != null) {
                    Blob blob = Blobs.createBlob(in);
                    blob.setFilename(seamMPRequest.getFileName(name));
                    blobs.add(blob);
                }
            }
        }
    } else {
        // fallback method for non-seam servlet request
        FileUpload fu = new FileUpload(new DiskFileItemFactory());
        String fileNameCharset = request.getHeader("FileNameCharset");
        if (fileNameCharset != null) {
            fu.setHeaderEncoding(fileNameCharset);
        }
        ServletRequestContext requestContext = new ServletRequestContext(request);
        List<FileItem> fileItems = fu.parseRequest(requestContext);
        for (FileItem item : fileItems) {
            try (InputStream is = item.getInputStream()) {
                Blob blob = Blobs.createBlob(is);
                blob.setFilename(item.getName());
                blobs.add(blob);
            }
        }
    }
    return blobs;
}

From source file:org.oscarehr.olis.OLISUploadSimulationDataAction.java

@Override
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) {//from  ww  w. ja v  a 2 s  .c o  m

    Logger logger = MiscUtils.getLogger();

    String simulationData = null;
    boolean simulationError = false;

    try {
        FileUpload upload = new FileUpload(new DefaultFileItemFactory());
        @SuppressWarnings("unchecked")
        List<FileItem> items = upload.parseRequest(request);
        for (FileItem item : items) {
            if (item.isFormField()) {
                String name = item.getFieldName();
                if (name.equals("simulateError")) {
                    simulationError = true;
                }
            } else {
                if (item.getFieldName().equals("simulateFile")) {
                    InputStream is = item.getInputStream();
                    StringWriter writer = new StringWriter();
                    IOUtils.copy(is, writer, "UTF-8");
                    simulationData = writer.toString();
                }
            }
        }

        if (simulationData != null && simulationData.length() > 0) {
            if (simulationError) {
                Driver.readResponseFromXML(request, simulationData);
                simulationData = (String) request.getAttribute("olisResponseContent");
                request.getSession().setAttribute("errors", request.getAttribute("errors"));
            }
            request.getSession().setAttribute("olisResponseContent", simulationData);
            request.setAttribute("result", "File successfully uploaded");
        }
    } catch (Exception e) {
        MiscUtils.getLogger().error("Error", e);
    }

    return mapping.findForward("success");
}

From source file:org.restlet.ext.jaxrs.internal.provider.FileUploadProvider.java

/**
 * @see MessageBodyReader#readFrom(Class, Type, Annotation[], MediaType,
 *      MultivaluedMap, InputStream)//from ww  w .  ja va  2s  .  c  om
 */
public List<FileItem> readFrom(Class<List<FileItem>> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, final MultivaluedMap<String, String> respHeaders, final InputStream entityStream)
        throws IOException {
    final FileUpload rfu = new FileUpload();
    final RequestContext requCtx = new RequestContext(entityStream, respHeaders);
    try {
        return rfu.parseRequest(requCtx);
    } catch (FileUploadException e) {
        if (e.getCause() instanceof IOException) {
            throw (IOException) e.getCause();
        }
        final IOException ioExc = new IOException("Could not read the multipart/form-data");
        ioExc.initCause(e);
        throw ioExc;
    }
}

From source file:org.seasar.cubby.controller.impl.MultipartRequestParser.java

@SuppressWarnings("unchecked")
Map<String, Object[]> getMultipartParameterMap(final FileUpload fileUpload,
        final RequestContext requestContext) {
    try {// w w  w  . j  a v a 2s  .  co m
        final String encoding = requestContext.getCharacterEncoding();
        fileUpload.setHeaderEncoding(encoding);
        final List<FileItem> items = fileUpload.parseRequest(requestContext);

        // Field????
        final Map<String, Object[]> parameterMap = toParameterMap(encoding, items);

        return parameterMap;
    } catch (final FileUploadException e) {
        final String messageCode;
        final Object[] args;
        if (e instanceof SizeLimitExceededException) {
            final SizeLimitExceededException sle = (SizeLimitExceededException) e;
            messageCode = "ECUB0202";
            args = new Object[] { sle.getPermittedSize(), sle.getActualSize() };
        } else {
            messageCode = "ECUB0201";
            args = new Object[] { e };
        }
        throw new RequestParseException(format(messageCode, args), e);
    } catch (final IOException e) {
        throw new RequestParseException(e);
    }
}