Example usage for org.apache.commons.fileupload FileItemStream getContentType

List of usage examples for org.apache.commons.fileupload FileItemStream getContentType

Introduction

In this page you can find the example usage for org.apache.commons.fileupload FileItemStream getContentType.

Prototype

String getContentType();

Source Link

Document

Returns the content type passed by the browser or null if not defined.

Usage

From source file:org.bimserver.servlets.UploadServlet.java

@Override
public void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    if (request.getHeader("Origin") != null
            && !getBimServer().getServerSettingsCache().isHostAllowed(request.getHeader("Origin"))) {
        response.setStatus(403);//from www . ja  v a 2s  . c o m
        return;
    }
    response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
    response.setHeader("Access-Control-Allow-Headers", "Content-Type");

    String token = (String) request.getSession().getAttribute("token");

    ObjectNode result = OBJECT_MAPPER.createObjectNode();
    response.setContentType("text/json");
    try {
        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
        long poid = -1;
        String comment = null;
        if (isMultipart) {
            ServletFileUpload upload = new ServletFileUpload();
            FileItemIterator iter = upload.getItemIterator(request);
            InputStream in = null;
            String name = "";
            long deserializerOid = -1;
            boolean merge = false;
            boolean sync = false;
            String compression = null;
            String action = null;
            long topicId = -1;
            while (iter.hasNext()) {
                FileItemStream item = iter.next();
                if (item.isFormField()) {
                    if ("action".equals(item.getFieldName())) {
                        action = Streams.asString(item.openStream());
                    } else if ("token".equals(item.getFieldName())) {
                        token = Streams.asString(item.openStream());
                    } else if ("poid".equals(item.getFieldName())) {
                        poid = Long.parseLong(Streams.asString(item.openStream()));
                    } else if ("comment".equals(item.getFieldName())) {
                        comment = Streams.asString(item.openStream());
                    } else if ("topicId".equals(item.getFieldName())) {
                        topicId = Long.parseLong(Streams.asString(item.openStream()));
                    } else if ("sync".equals(item.getFieldName())) {
                        sync = Streams.asString(item.openStream()).equals("true");
                    } else if ("merge".equals(item.getFieldName())) {
                        merge = Streams.asString(item.openStream()).equals("true");
                    } else if ("compression".equals(item.getFieldName())) {
                        compression = Streams.asString(item.openStream());
                    } else if ("deserializerOid".equals(item.getFieldName())) {
                        deserializerOid = Long.parseLong(Streams.asString(item.openStream()));
                    }
                } else {
                    name = item.getName();
                    in = item.openStream();

                    if ("file".equals(action)) {
                        ServiceInterface serviceInterface = getBimServer().getServiceFactory()
                                .get(token, AccessMethod.INTERNAL).get(ServiceInterface.class);
                        SFile file = new SFile();
                        byte[] data = IOUtils.toByteArray(in);
                        file.setData(data);
                        file.setSize(data.length);
                        file.setFilename(name);
                        file.setMime(item.getContentType());
                        result.put("fileId", serviceInterface.uploadFile(file));
                    } else if (poid != -1) {
                        InputStream realStream = null;
                        if ("gzip".equals(compression)) {
                            realStream = new GZIPInputStream(in);
                        } else if ("deflate".equals(compression)) {
                            realStream = new InflaterInputStream(in);
                        } else {
                            realStream = in;
                        }
                        InputStreamDataSource inputStreamDataSource = new InputStreamDataSource(realStream);
                        inputStreamDataSource.setName(name);
                        DataHandler ifcFile = new DataHandler(inputStreamDataSource);

                        if (token != null) {
                            if (topicId == -1) {
                                ServiceInterface service = getBimServer().getServiceFactory()
                                        .get(token, AccessMethod.INTERNAL).get(ServiceInterface.class);
                                long newTopicId = service.checkin(poid, comment, deserializerOid, -1L, name,
                                        ifcFile, merge, sync);
                                result.put("topicId", newTopicId);
                            } else {
                                ServiceInterface service = getBimServer().getServiceFactory()
                                        .get(token, AccessMethod.INTERNAL).get(ServiceInterface.class);
                                long newTopicId = service.checkinInitiated(topicId, poid, comment,
                                        deserializerOid, -1L, name, ifcFile, merge, true);
                                result.put("topicId", newTopicId);
                            }
                        }
                    } else {
                        result.put("exception", "No poid");
                    }
                }
            }
        }
    } catch (Exception e) {
        LOGGER.error("", e);
        sendException(response, e);
        return;
    }
    response.getWriter().write(result.toString());
}

From source file:org.brutusin.rpc.http.RpcServlet.java

/**
 *
 * @param req/*from  www  .ja v a 2  s  .c  o  m*/
 * @param rpcRequest
 * @param service
 * @return
 * @throws Exception
 */
private Map<String, InputStream> getStreams(HttpServletRequest req, RpcRequest rpcRequest, HttpAction service)
        throws Exception {
    if (!FileUploadBase.isMultipartContent(new ServletRequestContext(req))) {
        return null;
    }
    int streamsNumber = getInputStreamsNumber(rpcRequest, service);
    boolean isResponseStreamed = service.isBinaryResponse();
    FileItemIterator iter = (FileItemIterator) req.getAttribute(REQ_ATT_MULTIPART_ITERATOR);
    int count = 0;
    final Map<String, InputStream> map = new HashMap();
    final File tempDirectory;
    if (streamsNumber > 1 || streamsNumber == 1 && isResponseStreamed) {
        tempDirectory = createTempUploadDirectory();
        req.setAttribute(REQ_ATT_TEMPORARY_FOLDER, tempDirectory);
    } else {
        tempDirectory = null;
    }
    FileItemStream item = (FileItemStream) req.getAttribute(REQ_ATT_MULTIPART_CURRENT_ITEM);
    long availableLength = RpcConfig.getInstance().getMaxRequestSize();
    while (item != null) {
        count++;
        long maxLength = Math.min(availableLength, RpcConfig.getInstance().getMaxFileSize());
        if (count < streamsNumber || isResponseStreamed) { // if response is streamed all inputstreams have to be readed first
            File file = new File(tempDirectory, item.getFieldName());
            FileOutputStream fos = new FileOutputStream(file);
            try {
                Miscellaneous.pipeSynchronously(new LimitedLengthInputStream(item.openStream(), maxLength),
                        fos);
            } catch (MaxLengthExceededException ex) {
                if (maxLength == RpcConfig.getInstance().getMaxFileSize()) {
                    throw new MaxLengthExceededException(
                            "Upload part '" + item.getFieldName() + "' exceeds maximum length ("
                                    + RpcConfig.getInstance().getMaxFileSize() + " bytes)",
                            RpcConfig.getInstance().getMaxFileSize());
                } else {
                    throw new MaxLengthExceededException("Request exceeds maximum length ("
                            + RpcConfig.getInstance().getMaxRequestSize() + " bytes)",
                            RpcConfig.getInstance().getMaxRequestSize());
                }
            }
            map.put(item.getFieldName(), new MetaDataInputStream(new FileInputStream(file), item.getName(),
                    item.getContentType(), file.length(), null));
            availableLength -= file.length();
        } else if (count == streamsNumber) {
            map.put(item.getFieldName(),
                    new MetaDataInputStream(new LimitedLengthInputStream(item.openStream(), maxLength),
                            item.getName(), item.getContentType(), null, null));
            break;
        }
        req.setAttribute(REQ_ATT_MULTIPART_CURRENT_ITEM, item);
        if (iter.hasNext()) {
            item = iter.next();
        } else {
            item = null;
        }
    }
    if (count != streamsNumber) {
        throw new IllegalArgumentException("Invalid multipart request received. Number of uploaded files ("
                + count + ") does not match expected (" + streamsNumber + ")");
    }
    return map;
}

From source file:org.cellprofiler.subimager.ImageWriterHandler.java

public void handle(HttpExchange exchange) throws IOException {
    if (!exchange.getRequestMethod().equals("POST")) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_METHOD,
                "<html><body>writeimage only accepts HTTP post</body></html>");
        return;/* w ww  .j  av a2 s  . c  om*/
    }
    final String contentType = exchange.getRequestHeaders().getFirst("Content-Type");
    if (contentType == null) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                "<html><body>No Content-type request header</body></html>");
        return;
    }
    if (!contentType.startsWith(MULTIPART_FORM_DATA)) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                "<html><body>Content type must be " + MULTIPART_FORM_DATA + ".</body></html>");
        return;
    }
    int idx = contentType.indexOf(BOUNDARY_EQUALS, MULTIPART_FORM_DATA.length());
    if (idx == -1) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                "<html><body>Did not find boundary identifier in multipart/form-data content type.</body></html>");
        return;
    }
    final String contentEncoding = exchange.getRequestHeaders().getFirst("Content-Encoding");
    String contentLengthString = exchange.getRequestHeaders().getFirst("Content-Length");
    if (contentLengthString == null) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                "<html><body>No Content-Length request header</body></html>");
        return;
    }
    try {
        Integer.parseInt(contentLengthString);
    } catch (NumberFormatException e) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST, String
                .format("<html><body>Content length was not a number: %s</body></html>", contentLengthString));
        return;
    }
    final int contentLength = Integer.parseInt(contentLengthString);
    final InputStream requestBodyStream = exchange.getRequestBody();
    FileUpload upload = new FileUpload();
    FileItemIterator fileItemIterator;
    String omeXML = null;
    URI uri = null;
    int index = 0;
    NDImage ndimage = null;
    String compression = DEFAULT_COMPRESSION;
    try {
        fileItemIterator = upload.getItemIterator(new RequestContext() {

            public String getCharacterEncoding() {
                return contentEncoding;
            }

            public String getContentType() {
                return contentType;
            }

            public int getContentLength() {
                return contentLength;
            }

            public InputStream getInputStream() throws IOException {
                return requestBodyStream;
            }
        });
        while (fileItemIterator.hasNext()) {
            FileItemStream fis = fileItemIterator.next();
            String name = fis.getFieldName();

            if (name.equals(NAME_IMAGE)) {
                String imageContentType = fis.getContentType();
                if (imageContentType == null) {
                    reportError(exchange, HttpURLConnection.HTTP_UNSUPPORTED_TYPE,
                            "<html><body>Image form-data field must have a content type.</body></html>");
                    return;
                }
                try {
                    InputStream is = SubimagerUtils.getInputStream(exchange, fis);
                    if (is == null)
                        return;
                    ndimage = NDImage.decode(is);
                } catch (MalformedStreamException e) {
                    reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                            "<html><body>Failed to read body for part, " + name + ".</body></html>");
                } catch (IOException e) {
                    reportError(exchange, HttpURLConnection.HTTP_INTERNAL_ERROR,
                            "<html><body>Failed to read multipart body data</body></html>");
                    return;
                } catch (org.cellprofiler.subimager.NDImage.FormatException e) {
                    reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                            "<html><body>Image data was not in correct format: " + e.getMessage()
                                    + "</body></html>");
                    return;
                }
            } else {
                String partDataString = SubimagerUtils.readFully(exchange, fis);
                if (partDataString == null)
                    return;
                if (name.equals(NAME_INDEX)) {
                    try {
                        index = Integer.parseInt(partDataString);
                    } catch (NumberFormatException e) {
                        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                                "<html><body>Index form-data field must be a number: " + partDataString
                                        + ".</body></html>");
                        return;
                    }
                } else if (name.equals(NAME_OMEXML)) {
                    omeXML = partDataString;
                } else if (name.equals(NAME_URL)) {
                    try {
                        uri = new URI(partDataString);
                    } catch (URISyntaxException e) {
                        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                                "<html><body>Improperly formatted URL: " + partDataString + ".</body></html>");
                        return;
                    }
                } else if (name.equals(NAME_COMPRESSION)) {
                    compression = partDataString;
                }
            }
        }
        if (ndimage == null) {
            reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                    "<html><body>Request did not have an image part</body></html>");
            return;
        }
        if (uri == null) {
            reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                    "<html><body>Request did not have a URL part</body></html>");
            return;
        }
        if (omeXML == null) {
            reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST,
                    "<html><body>Request did not have an omexml part</body></html>");
            return;
        }
        writeImage(exchange, ndimage, uri, omeXML, index, compression);
    } catch (FileUploadException e) {
        reportError(exchange, HttpURLConnection.HTTP_BAD_REQUEST, String
                .format("<html><body>Parsing error in multipart message: %s</body></html>", e.getMessage()));
        return;
    }
}

From source file:org.celstec.arlearn2.upload.BlobStoreServlet.java

protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    try {/*w  w w  . j a v a  2  s  . c om*/
        Long runId = null;
        String account = null;
        ServletFileUpload upload = new ServletFileUpload();
        res.setContentType("text/plain");

        FileItemIterator iterator = upload.getItemIterator(req);

        while (iterator.hasNext()) {
            FileItemStream item = iterator.next();
            InputStream stream = item.openStream();

            if (item.isFormField()) {
                if ("runId".equals(item.getFieldName())) {
                    runId = Long.parseLong(Streams.asString(stream));
                }
                if ("account".equals(item.getFieldName())) {
                    account = Streams.asString(stream);
                }
            } else {
                BlobKey blobkey = storeBlob(item.getContentType(), item.getName(), stream);
                if (blobkey != null) {
                    System.out.println(blobkey);
                    // File exists
                    BlobKey oldkey = FilePathManager.getBlobKey(account, runId, item.getName());
                    if (oldkey != null) {
                        FilePathManager.delete(oldkey);
                        blobstoreService.delete(oldkey);
                    }
                    FilePathManager.addFile(runId, account, item.getName(), blobkey);

                } else {
                    blobkey.toString();
                }

            }
        }
    } catch (Exception ex) {
        throw new ServletException(ex);
    }
}

From source file:org.celstec.arlearn2.upload.BlobStoreServletIncremental.java

protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    try {/*from  w  ww .  j a v  a  2s. c  o m*/
        Long runId = null;
        String account = null;
        String serverPath = null;
        boolean last = false;
        ServletFileUpload upload = new ServletFileUpload();
        res.setContentType("text/plain");

        FileItemIterator iterator = upload.getItemIterator(req);
        System.out.println("before while");
        while (iterator.hasNext()) {
            System.out.println("in while");
            FileItemStream item = iterator.next();
            InputStream stream = item.openStream();

            if (item.isFormField()) {
                if ("runId".equals(item.getFieldName())) {
                    runId = Long.parseLong(Streams.asString(stream));
                    System.out.println("runid is " + runId);
                }

                if ("account".equals(item.getFieldName())) {
                    account = Streams.asString(stream);
                    System.out.println("account is " + account);
                }
                if ("last".equals(item.getFieldName())) {
                    last = Boolean.parseBoolean(Streams.asString(stream));
                    System.out.println("last is " + last);
                }
                if ("serverPath".equals(item.getFieldName())) {
                    serverPath = Streams.asString(stream);
                    System.out.println("serverPath is " + serverPath);
                }

            } else {
                log.warning("Got an uploaded file: " + item.getFieldName() + ", name = " + item.getName());
                AppEngineFile file = storeBlob(item.getContentType(), item.getName(), stream, last, serverPath);

                BlobKey blobkey = fileService.getBlobKey(file);
                if (blobkey != null) {
                    // File exists
                    BlobKey oldkey = FilePathManager.getBlobKey(account, runId, item.getName());
                    if (oldkey != null) {
                        FilePathManager.delete(oldkey);
                        blobstoreService.delete(oldkey);
                    }
                    FilePathManager.addFile(runId, account, item.getName(), blobkey);
                    System.out.println(blobkey.toString());
                }
                res.getWriter().write(file.getFullPath());
                //               else {
                //                  blobkey.toString();
                //               }

            }
        }
    } catch (Exception ex) {
        throw new ServletException(ex);
    }
}

From source file:org.codelabor.system.file.web.servlet.FileUploadStreamServlet.java

@Override
protected void upload(HttpServletRequest request, HttpServletResponse response) throws Exception {
    WebApplicationContext ctx = WebApplicationContextUtils
            .getRequiredWebApplicationContext(this.getServletContext());
    FileManager fileManager = (FileManager) ctx.getBean("fileManager");

    boolean isMultipart = ServletFileUpload.isMultipartContent(request);
    Map<String, Object> paramMap = RequestUtils.getParameterMap(request);
    if (logger.isDebugEnabled()) {
        logger.debug(paramMap.toString());
    }/*from   w  w  w .j  a v a 2 s  . com*/

    String mapId = (String) paramMap.get("mapId");
    RepositoryType acceptedRepositoryType = repositoryType;
    String requestedRepositoryType = (String) paramMap.get("repositoryType");
    if (StringUtils.isNotEmpty(requestedRepositoryType)) {
        acceptedRepositoryType = RepositoryType.valueOf(requestedRepositoryType);
    }

    if (isMultipart) {
        ServletFileUpload upload = new ServletFileUpload();
        upload.setFileSizeMax(fileSizeMax);
        upload.setSizeMax(requestSizeMax);
        upload.setHeaderEncoding(characterEncoding);
        upload.setProgressListener(new FileUploadProgressListener());
        try {
            FileItemIterator iter = upload.getItemIterator(request);

            while (iter.hasNext()) {
                FileItemStream fileItemSteam = iter.next();
                if (logger.isDebugEnabled()) {
                    logger.debug(fileItemSteam.toString());
                }
                FileDTO fileDTO = null;
                if (fileItemSteam.isFormField()) {
                    paramMap.put(fileItemSteam.getFieldName(),
                            Streams.asString(fileItemSteam.openStream(), characterEncoding));
                } else {
                    if (fileItemSteam.getName() == null || fileItemSteam.getName().length() == 0)
                        continue;

                    // set DTO
                    fileDTO = new FileDTO();
                    fileDTO.setMapId(mapId);
                    fileDTO.setRealFilename(FilenameUtils.getName(fileItemSteam.getName()));
                    if (acceptedRepositoryType == RepositoryType.FILE_SYSTEM) {
                        fileDTO.setUniqueFilename(getUniqueFilename());
                    }
                    fileDTO.setContentType(fileItemSteam.getContentType());
                    fileDTO.setRepositoryPath(realRepositoryPath);
                    if (logger.isDebugEnabled()) {
                        logger.debug(fileDTO.toString());
                    }
                    UploadUtils.processFile(acceptedRepositoryType, fileItemSteam.openStream(), fileDTO);
                }
                if (fileDTO != null)
                    fileManager.insertFile(fileDTO);
            }
        } catch (FileUploadException e) {
            e.printStackTrace();
            logger.error(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.getMessage());
        }
    } else {
        paramMap = RequestUtils.getParameterMap(request);
    }
    try {
        processParameters(paramMap);
    } catch (Exception e) {
        e.printStackTrace();
        logger.error(e.getMessage());
    }
    dispatch(request, response, forwardPathUpload);

}

From source file:org.duracloud.common.rest.RestUtilImpl.java

/**
 * Retrieves the contents of the HTTP Request.
 *
 * @return InputStream from the request/*from  www.j a v a  2  s.c o m*/
 */
@Override
public RequestContent getRequestContent(HttpServletRequest request, HttpHeaders headers) throws Exception {
    RequestContent rContent = null;

    // See if the request is a multi-part file upload request
    if (ServletFileUpload.isMultipartContent(request)) {

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

        // Parse the request, use the first available File item
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
            FileItemStream item = iter.next();
            if (!item.isFormField()) {
                rContent = new RequestContent();
                rContent.contentStream = item.openStream();
                rContent.mimeType = item.getContentType();

                FileItemHeaders itemHeaders = item.getHeaders();
                if (itemHeaders != null) {
                    String contentLength = itemHeaders.getHeader("Content-Length");
                    if (contentLength != null) {
                        rContent.size = Long.parseLong(contentLength);
                    }
                }

                break;
            }
        }
    } else {
        // If the content stream was not found as a multipart,
        // try to use the stream from the request directly
        rContent = new RequestContent();
        rContent.contentStream = request.getInputStream();
        if (request.getContentLength() >= 0) {
            rContent.size = request.getContentLength();
        }
    }

    // Attempt to set the mime type and size if not already set
    if (rContent != null) {
        if (rContent.mimeType == null) {
            MediaType mediaType = headers.getMediaType();
            if (mediaType != null) {
                rContent.mimeType = mediaType.toString();
            }
        }

        if (rContent.size == 0) {
            List<String> lengthHeaders = headers.getRequestHeader("Content-Length");
            if (lengthHeaders != null && lengthHeaders.size() > 0) {
                rContent.size = Long.parseLong(lengthHeaders.get(0));
            }
        }
    }

    return rContent;
}

From source file:org.duracloud.duradmin.spaces.controller.ContentItemUploadController.java

@RequestMapping(value = "/spaces/content/upload", method = RequestMethod.POST)
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
    try {/*  w  ww  .  j  a  v  a2  s  . c om*/
        log.debug("handling request...");

        ServletFileUpload upload = new ServletFileUpload();
        FileItemIterator iter = upload.getItemIterator(request);
        String spaceId = null;
        String storeId = null;
        String contentId = null;
        List<ContentItem> results = new ArrayList<ContentItem>();

        while (iter.hasNext()) {
            FileItemStream item = iter.next();
            if (item.isFormField()) {
                String value = Streams.asString(item.openStream(), "UTF-8");
                if (item.getFieldName().equals("spaceId")) {
                    log.debug("setting spaceId: {}", value);
                    spaceId = value;
                } else if (item.getFieldName().equals("storeId")) {
                    storeId = value;
                } else if (item.getFieldName().equals("contentId")) {
                    contentId = value;
                }
            } else {
                log.debug("setting fileStream: {}", item);

                if (StringUtils.isBlank(spaceId)) {
                    throw new IllegalArgumentException("space id required.");
                }

                ContentItem ci = new ContentItem();
                if (StringUtils.isBlank(contentId)) {
                    contentId = item.getName();
                }

                ci.setContentId(contentId);
                ci.setSpaceId(spaceId);
                ci.setStoreId(storeId);
                ci.setContentMimetype(item.getContentType());
                ContentStore contentStore = contentStoreManager.getContentStore(ci.getStoreId());
                ContentItemUploadTask task = new ContentItemUploadTask(ci, contentStore, item.openStream(),
                        request.getUserPrincipal().getName());

                task.execute();
                ContentItem result = new ContentItem();
                Authentication auth = (Authentication) SecurityContextHolder.getContext().getAuthentication();
                SpaceUtil.populateContentItem(ContentItemController.getBaseURL(request), result,
                        ci.getSpaceId(), ci.getContentId(), contentStore, auth);
                results.add(result);
                contentId = null;
            }
        }

        return new ModelAndView("javascriptJsonView", "results", results);

    } catch (Exception ex) {
        ex.printStackTrace();
        throw ex;
    }

}

From source file:org.eclipse.rap.addons.fileupload.internal.FileUploadProcessor.java

private void receive(FileItemStream item) throws IOException {
    InputStream stream = item.openStream();
    try {/*ww  w.  j  a  v  a 2  s  .c o m*/
        String fileName = stripFileName(item.getName());
        String contentType = item.getContentType();
        FileDetails details = new FileDetailsImpl(fileName, contentType, -1);
        FileUploadReceiver receiver = handler.getReceiver();
        receiver.receive(stream, details);
        tracker.addFile(details);
    } finally {
        stream.close();
    }
}

From source file:org.eclipse.rap.fileupload.internal.FileUploadProcessor.java

private void receive(FileItemStream item) throws IOException {
    InputStream stream = item.openStream();
    try {/*from   w  ww  .  ja v a  2s .  co  m*/
        String fileName = stripFileName(item.getName());
        String contentType = item.getContentType();
        FileDetails details = new FileDetailsImpl(fileName, contentType);
        FileUploadReceiver receiver = handler.getReceiver();
        receiver.receive(stream, details);
        tracker.addFile(details);
    } finally {
        stream.close();
    }
}