Example usage for io.vertx.core.file AsyncFile close

Introduction

In this page you can find the example usage for io.vertx.core.file AsyncFile close.

Prototype

Future<Void> close();

Source Link

Document

Close the file.

Usage

From source file:com.deblox.releaseboard.ReleaseBoardVerticle.java

License:Apache License

public void saveState() {
    logger.info("saving state");
    JsonObject db = new JsonObject();
    JsonArray releases = new JsonArray();

    Iterator<Map.Entry<String, JsonObject>> iter = releasesData.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry<String, JsonObject> entry = iter.next();
        JsonObject rel = new JsonObject();
        rel.put("id", entry.getKey());
        rel.put("data", entry.getValue());
        releases.add(rel);/* www. j  a va  2 s. c  o m*/
    }

    db.put("releases", releases);

    vertx.fileSystem().exists(stateFile, te -> {
        if (te.succeeded()) {
            if (te.result().booleanValue()) {
                vertx.fileSystem().deleteBlocking(stateFile);
                vertx.fileSystem().createFileBlocking(stateFile);
            } else {
                vertx.fileSystem().createFileBlocking(stateFile);
            }

        } else {
            logger.warn("unable to check if file exists: " + stateFile);
        }

        vertx.fileSystem().open(stateFile, new OpenOptions().setCreate(true).setWrite(true), r -> {
            if (r.succeeded()) {
                AsyncFile file = r.result();
                file.write(Buffer.buffer(db.toString()));
                file.close();
            } else {
                logger.warn(r.cause());
            }
        });

    });

}

---

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

License:Open Source License

@Override
public void writeFsFile(final String id, final String filePath, final Handler<JsonObject> handler) {
    if (id == null || id.trim().isEmpty() || filePath == null || filePath.trim().isEmpty()
            || filePath.endsWith(File.separator)) {
        handler.handle(new JsonObject().put("status", "error").put("message", "invalid.parameter"));
        return;/*www .j  av  a2 s . co  m*/
    }
    final String filename = filePath.contains(File.separator)
            ? filePath.substring(filePath.lastIndexOf(File.separator) + 1)
            : filePath;
    final String contentType = getContentType(filePath);
    vertx.fileSystem().props(filePath, new Handler<AsyncResult<FileProps>>() {
        @Override
        public void handle(AsyncResult<FileProps> event) {
            if (event.succeeded()) {
                final long fileSize = event.result().size();
                vertx.fileSystem().open(filePath, new OpenOptions(), new Handler<AsyncResult<AsyncFile>>() {
                    @Override
                    public void handle(AsyncResult<AsyncFile> event) {
                        if (event.succeeded()) {
                            final AsyncFile asyncFile = event.result();
                            int nbChunks = (int) Math.ceil(fileSize / BUFFER_SIZE);
                            final Handler[] handlers = new Handler[nbChunks + 1];

                            handlers[handlers.length - 1] = new Handler<AsyncResult<Buffer>>() {
                                @Override
                                public void handle(AsyncResult<Buffer> asyncResult) {
                                    if (asyncResult.failed()) {
                                        handler.handle(new JsonObject().put("status", "error").put("message",
                                                asyncResult.cause().getMessage()));
                                        return;
                                    }
                                    Buffer buff = asyncResult.result();
                                    saveChunk(id, buff, handlers.length - 1, contentType, filename, fileSize,
                                            handler);
                                    asyncFile.close();
                                }
                            };

                            for (int i = nbChunks - 1; i >= 0; i--) {
                                final int j = i;
                                handlers[i] = new Handler<AsyncResult<Buffer>>() {
                                    @Override
                                    public void handle(AsyncResult<Buffer> asyncResult) {
                                        if (asyncResult.failed()) {
                                            handler.handle(new JsonObject().put("status", "error")
                                                    .put("message", asyncResult.cause().getMessage()));
                                            return;
                                        }
                                        Buffer buff = asyncResult.result();
                                        saveChunk(id, buff, j, contentType, filename, fileSize,
                                                new Handler<JsonObject>() {
                                                    @Override
                                                    public void handle(JsonObject message) {
                                                        if ("ok".equals(message.getString("status"))) {
                                                            asyncFile.read(Buffer.buffer((int) BUFFER_SIZE), 0,
                                                                    (j + 1) * BUFFER_SIZE, (int) BUFFER_SIZE,
                                                                    handlers[j + 1]);
                                                        } else {
                                                            handler.handle(message);
                                                        }
                                                    }
                                                });
                                    }
                                };
                            }

                            asyncFile.read(Buffer.buffer((int) BUFFER_SIZE), 0, 0, (int) BUFFER_SIZE,
                                    handlers[0]);

                        } else {
                            handler.handle(new JsonObject().put("status", "error").put("message",
                                    event.cause().getMessage()));
                        }
                    }
                });
            } else {
                handler.handle(
                        new JsonObject().put("status", "error").put("message", event.cause().getMessage()));
            }
        }
    });
}

---