Example usage for io.vertx.core.http HttpServerFileUpload exceptionHandler

Introduction

In this page you can find the example usage for io.vertx.core.http HttpServerFileUpload exceptionHandler.

Prototype

@Override
    HttpServerFileUpload exceptionHandler(Handler<Throwable> handler);

Source Link

Usage

From source file:org.entcore.common.storage.impl.FileStorage.java

License:Open Source License

@Override
public void writeUploadFile(final HttpServerRequest request, final Long maxSize,
        final Handler<JsonObject> handler) {
    request.pause();// ww w.j a va 2s. co m
    final String id = UUID.randomUUID().toString();
    final String path;
    final JsonObject res = new JsonObject();
    try {
        path = getPath(id);
    } catch (FileNotFoundException e) {
        handler.handle(res.put("status", "error").put("message", "invalid.path"));
        log.warn(e.getMessage(), e);
        return;
    }
    request.setExpectMultipart(true);
    request.uploadHandler(new Handler<HttpServerFileUpload>() {
        @Override
        public void handle(final HttpServerFileUpload upload) {
            request.pause();
            final JsonObject metadata = FileUtils.metadata(upload);
            if (validator != null) {
                validator.process(metadata, new JsonObject().put("maxSize", maxSize),
                        new Handler<AsyncResult<Void>>() {
                            @Override
                            public void handle(AsyncResult<Void> event) {
                                if (event.succeeded()) {
                                    doUpload(upload, metadata);
                                } else {
                                    handler.handle(res.put("status", "error").put("message",
                                            event.cause().getMessage()));
                                }
                            }
                        });
            } else {
                doUpload(upload, metadata);
            }
        }

        private void doUpload(final HttpServerFileUpload upload, final JsonObject metadata) {
            upload.endHandler(new Handler<Void>() {
                @Override
                public void handle(Void event) {
                    if (metadata.getLong("size") == 0l) {
                        metadata.put("size", upload.size());
                        if (maxSize != null && maxSize < metadata.getLong("size", 0l)) {
                            handler.handle(res.put("status", "error").put("message", "file.too.large"));
                            try {
                                fs.delete(getPath(id), new Handler<AsyncResult<Void>>() {
                                    @Override
                                    public void handle(AsyncResult<Void> event) {
                                        if (event.failed()) {
                                            log.error(event.cause().getMessage(), event.cause());
                                        }
                                    }
                                });
                            } catch (FileNotFoundException e) {
                                log.error(e.getMessage(), e);
                            }
                        }
                    }
                    handler.handle(res.put("_id", id).put("status", "ok").put("metadata", metadata));
                    scanFile(path);
                }
            });
            upload.exceptionHandler(new Handler<Throwable>() {
                @Override
                public void handle(Throwable event) {
                    handler.handle(res.put("status", "error"));
                    log.error(event.getMessage(), event);
                }
            });
            upload.streamToFileSystem(path);
        }
    });
    mkdirsIfNotExists(id, path, new Handler<AsyncResult<Void>>() {
        @Override
        public void handle(AsyncResult<Void> event) {
            if (event.succeeded()) {
                request.resume();
            } else {
                handler.handle(res.put("status", "error"));
                log.error(event.cause().getMessage(), event.cause());
            }
        }
    });
}

---

From source file:org.wisdom.framework.vertx.file.MixedFileUpload.java

License:Apache License

/**
 * Creates an instance of {@link org.wisdom.framework.vertx.file.VertxFileUpload}.
 *
 * @param vertx     the Vert.X instance//www  . j  a va2s . c o  m
 * @param upload    the upload object
 * @param limitSize the threshold. If the amount of uploaded data is below this limit,
 *                  {@link org.wisdom.framework.vertx.file.MemoryFileUpload} is used to backend the uploaded file.
 *                  Otherwise, it uses a {@link org.wisdom.framework.vertx.file.DiskFileUpload}.
 */
public MixedFileUpload(final Vertx vertx, final HttpServerFileUpload upload, final long limitSize,
        final long maxSize, final Handler<Result> errorHandler) {
    super(upload, errorHandler);
    delegate = new MemoryFileUpload(upload, errorHandler);

    upload.exceptionHandler(event -> LoggerFactory.getLogger(MixedFileUpload.class)
            .error("Cannot read the uploaded item {} ({})", upload.name(), upload.filename(), event))
            .endHandler(event -> delegate.close()).handler(event -> {
                if (event != null) {
                    // We are still in memory.
                    if (delegate instanceof MemoryFileUpload) {
                        MemoryFileUpload mem = (MemoryFileUpload) delegate;
                        checkSize(mem.buffer.length() + event.length(), maxSize, upload);
                        if (mem.buffer.length() + event.length() > limitSize) {
                            // Switch to disk file upload.
                            DiskFileUpload disk = new DiskFileUpload(vertx, upload, errorHandler);
                            // Initial push (mem + current buffer)
                            disk.push(mem.buffer.appendBuffer(event));
                            // No cleanup required for the memory based backend.
                            delegate = disk;

                            // the disk based implementation use a pump.
                        } else {
                            delegate.push(event);
                        }
                    }
                }
            });
}

---