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

List of usage examples for io.vertx.core.http HttpServerFileUpload streamToFileSystem

Introduction

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

Prototype

@Fluent
HttpServerFileUpload streamToFileSystem(String filename);

Source Link

Document

Stream the content of this upload to the given file on storage.

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();/* w  w w  .java 2s  .  c om*/
    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.entcore.directory.controllers.ImportController.java

License:Open Source License

private void uploadImport(final HttpServerRequest request, final Handler<AsyncResult<ImportInfos>> handler) {
    request.pause();/*from   www.  j av a  2  s . co m*/
    final String importId = UUID.randomUUID().toString();
    final String path = config.getString("wizard-path", "/tmp") + File.separator + importId;
    request.setExpectMultipart(true);
    request.endHandler(new Handler<Void>() {
        @Override
        public void handle(Void v) {
            final ImportInfos importInfos = new ImportInfos();
            importInfos.setId(importId);
            importInfos.setPath(path);
            importInfos.setStructureId(request.formAttributes().get("structureId"));
            importInfos.setStructureExternalId(request.formAttributes().get("structureExternalId"));
            importInfos.setPreDelete(paramToBoolean(request.formAttributes().get("predelete")));
            importInfos.setTransition(paramToBoolean(request.formAttributes().get("transition")));
            importInfos.setStructureName(request.formAttributes().get("structureName"));
            importInfos.setUAI(request.formAttributes().get("UAI"));
            importInfos.setLanguage(I18n.acceptLanguage(request));
            if (isNotEmpty(request.formAttributes().get("classExternalId"))) {
                importInfos.setOverrideClass(request.formAttributes().get("classExternalId"));
            }
            try {
                importInfos.setFeeder(request.formAttributes().get("type"));
            } catch (IllegalArgumentException | NullPointerException e) {
                handler.handle(
                        new DefaultAsyncResult<ImportInfos>(new ImportException("invalid.import.type", e)));
                deleteImportPath(vertx, path);
                return;
            }
            UserUtils.getUserInfos(eb, request, new Handler<UserInfos>() {
                @Override
                public void handle(UserInfos user) {
                    if (user == null) {
                        handler.handle(
                                new DefaultAsyncResult<ImportInfos>(new ImportException("invalid.admin")));
                        deleteImportPath(vertx, path);
                        return;
                    }
                    importInfos.validate(
                            user.getFunctions() != null
                                    && user.getFunctions().containsKey(DefaultFunctions.SUPER_ADMIN),
                            vertx, new Handler<AsyncResult<String>>() {
                                @Override
                                public void handle(AsyncResult<String> validate) {
                                    if (validate.succeeded()) {
                                        if (validate.result() == null) {
                                            handler.handle(new DefaultAsyncResult<>(importInfos));
                                        } else {
                                            handler.handle(new DefaultAsyncResult<ImportInfos>(
                                                    new ImportException(validate.result())));
                                            deleteImportPath(vertx, path);
                                        }
                                    } else {
                                        handler.handle(new DefaultAsyncResult<ImportInfos>(validate.cause()));
                                        log.error("Validate error", validate.cause());
                                        deleteImportPath(vertx, path);
                                    }
                                }
                            });
                }
            });
        }
    });
    request.exceptionHandler(new Handler<Throwable>() {
        @Override
        public void handle(Throwable event) {
            handler.handle(new DefaultAsyncResult<ImportInfos>(event));
            deleteImportPath(vertx, path);
        }
    });
    request.uploadHandler(new Handler<HttpServerFileUpload>() {
        @Override
        public void handle(final HttpServerFileUpload upload) {
            if (!upload.filename().toLowerCase().endsWith(".csv")) {
                handler.handle(
                        new DefaultAsyncResult<ImportInfos>(new ImportException("invalid.file.extension")));
                return;
            }
            final String filename = path + File.separator + upload.name();
            upload.endHandler(new Handler<Void>() {
                @Override
                public void handle(Void event) {
                    log.info("File " + upload.filename() + " uploaded as " + upload.name());
                }
            });
            upload.streamToFileSystem(filename);
        }
    });
    vertx.fileSystem().mkdir(path, new Handler<AsyncResult<Void>>() {
        @Override
        public void handle(AsyncResult<Void> event) {
            if (event.succeeded()) {
                request.resume();
            } else {
                handler.handle(
                        new DefaultAsyncResult<ImportInfos>(new ImportException("mkdir.error", event.cause())));
            }
        }
    });
}

From source file:org.entcore.directory.controllers.TimetableController.java

License:Open Source License

@Post("/timetable/import/:structureId")
@ResourceFilter(AdminFilter.class)
@SecuredAction(value = "", type = ActionType.RESOURCE)
public void importTimetable(final HttpServerRequest request) {
    request.pause();//w ww .  j a v  a  2  s  .  c o m
    final String importId = UUID.randomUUID().toString();
    final String path = config.getString("timetable-path", "/tmp") + File.separator + importId;
    request.setExpectMultipart(true);
    request.exceptionHandler(new Handler<Throwable>() {
        @Override
        public void handle(Throwable event) {
            badRequest(request, event.getMessage());
            deleteImportPath(vertx, path);
        }
    });
    request.uploadHandler(new Handler<HttpServerFileUpload>() {
        @Override
        public void handle(final HttpServerFileUpload upload) {
            final String filename = path + File.separator + upload.filename();
            upload.endHandler(new Handler<Void>() {
                @Override
                public void handle(Void event) {
                    timetableService.importTimetable(request.params().get("structureId"), filename,
                            getHost(request), I18n.acceptLanguage(request),
                            reportResponseHandler(vertx, path, request));
                }
            });
            upload.streamToFileSystem(filename);
        }
    });
    vertx.fileSystem().mkdir(path, new Handler<AsyncResult<Void>>() {
        @Override
        public void handle(AsyncResult<Void> event) {
            if (event.succeeded()) {
                request.resume();
            } else {
                badRequest(request, "mkdir.error");
            }
        }
    });
}