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

Introduction

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

Prototype

@Fluent
AsyncFile read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler);

Source Link

Document

Reads length bytes of data from the file at position position in the file, asynchronously.

Usage

From source file:examples.FileSystemExamples.java

License:Open Source License

public void asyncFileRead() {
    Vertx vertx = Vertx.vertx();//from   www  .j  a  v a2s .co  m
    vertx.fileSystem().open("target/classes/les_miserables.txt", new OpenOptions(), result -> {
        if (result.succeeded()) {
            AsyncFile file = result.result();
            Buffer buff = Buffer.buffer(1000);
            for (int i = 0; i < 10; i++) {
                file.read(buff, i * 100, i * 100, 100, ar -> {
                    if (ar.succeeded()) {
                        System.out.println("Read ok!");
                    } else {
                        System.err.println("Failed to write: " + ar.cause());
                    }
                });
            }
        } else {
            System.err.println("Cannot open file " + result.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;/*w  ww  . j  ava  2  s .  c  om*/
    }
    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()));
            }
        }
    });
}

---