Example usage for io.vertx.core.json JsonArray size

List of usage examples for io.vertx.core.json JsonArray size

  1. HOME
  2. Java
  3. io.vertx
  4. io.vertx.core.json.*
  5. JsonArray
  6. size

Introduction

In this page you can find the example usage for io.vertx.core.json JsonArray size.

Prototype

public int size()

Source Link

Document

Get the number of values in this JSON array

Usage

From source file:com.glencoesoftware.omero.ms.thumbnail.ThumbnailVerticle.java

License:Open Source License

/**
 * Get thumbnails event handler. Responds with a JSON dictionary of Base64
 * encoded <code>image/jpeg</code> thumbnails keyed by {@link Image}
 * identifier. Each dictionary value is prefixed with
 * <code>data:image/jpeg;base64,</code> so that it can be used with
 * <a href="http://caniuse.com/#feat=datauri">data URIs</a>.
 * @param message JSON encoded event data. Required keys are
 * <code>omeroSessionKey</code> (String), <code>longestSide</code>
 * (Integer), and <code>imageIds</code> (List<Long>).
 *//*from   w  w w  .ja  va2 s .c  o  m*/
private void getThumbnails(Message<String> message) {
    JsonObject data = new JsonObject(message.body());
    String omeroSessionKey = data.getString("omeroSessionKey");
    int longestSide = data.getInteger("longestSide");
    JsonArray imageIdsJson = data.getJsonArray("imageIds");
    List<Long> imageIds = new ArrayList<Long>();
    for (int i = 0; i < imageIdsJson.size(); i++) {
        imageIds.add(imageIdsJson.getLong(i));
    }
    log.debug("Render thumbnail request ImageIds:{} longest side {}", imageIds, longestSide);

    try (OmeroRequest request = new OmeroRequest(host, port, omeroSessionKey)) {
        Map<Long, byte[]> thumbnails = request
                .execute(new ThumbnailsRequestHandler(longestSide, imageIds)::renderThumbnails);

        if (thumbnails == null) {
            message.fail(404, "Cannot find one or more Images");
        } else {
            Map<Long, String> thumbnailsJson = new HashMap<Long, String>();
            for (Entry<Long, byte[]> v : thumbnails.entrySet()) {
                thumbnailsJson.put(v.getKey(), "data:image/jpeg;base64," + Base64.encode(v.getValue()));
            }
            message.reply(Json.encode(thumbnailsJson));
        }
    } catch (PermissionDeniedException | CannotCreateSessionException e) {
        String v = "Permission denied";
        log.debug(v);
        message.fail(403, v);
    } catch (Exception e) {
        String v = "Exception while retrieving thumbnail";
        log.error(v, e);
        message.fail(500, v);
    }
}

From source file:com.groupon.vertx.redis.RedisCommandHandler.java

License:Apache License

/**
 * This handles the incoming Redis command JSON.
 *
 * @param command - The JsonObject containing the commands to send to Redis.
 */// w  w w  .  j  a v a  2 s  .  com
public void handle(final Message<JsonObject> command) {
    if (command.body() == null || command.body().size() == 0) {
        log.warn("handleCommand", "failure", new String[] { "reason" }, "Missing message body");
        command.reply(buildReply("error", null, "Invalid message with null or empty."));
        return;
    }

    JsonObject inputJson = command.body();
    boolean isMulti = inputJson.getBoolean("isTransaction", false);
    JsonArray commands = inputJson.getJsonArray("commands", new JsonArray());
    if (commands.size() > 0) {
        LinkedList<RedisCommand> transactionRedisCommands = new LinkedList<>();
        for (Object jsonCommand : commands) {
            RedisCommand redisCommand = getRedisCommand((JsonObject) jsonCommand, command, isMulti);
            if (redisCommand == null) {
                log.warn("handleCommand", "failure", new String[] { "reason" }, "Invalid redis command");
                command.reply(buildReply("error", null, "Invalid redis command"));
                return;
            }
            transactionRedisCommands.add(redisCommand);
        }
        if (isMulti) { //Wrap it with a  MULTI and EXEC block
            transactionRedisCommands.addFirst(new RedisCommand(RedisCommandType.MULTI, null));
            transactionRedisCommands.addLast(new RedisCommand(RedisCommandType.EXEC, null));
            setCommandResponseHandler(Collections.singletonList(transactionRedisCommands.getLast()), command,
                    isMulti);
        } else {
            setCommandResponseHandler(transactionRedisCommands, command, isMulti);
        }
        socket.sendCommand(transactionRedisCommands);
    } else {
        log.warn("handleCommand", "failure", new String[] { "reason" }, "Missing commands");
        command.reply(buildReply("error", null, "Invalid message with no commands"));
    }
}

From source file:com.groupon.vertx.redis.RedisTransaction.java

License:Apache License

private JsonObject constructTransactionCommandResult(JsonObject response, int index) {
    JsonArray responses = response.getJsonArray("data");
    if (responses != null && responses.size() > index) {
        Object commandResult = responses.getValue(index);
        JsonObject result = new JsonObject();
        result.put("status", response.getString("status"));
        if (commandResult instanceof JsonArray) {
            result.put("data", (JsonArray) commandResult);
        } else if (commandResult instanceof String) {
            result.put("data", (String) commandResult);
        } else if (commandResult instanceof Number) {
            result.put("data", (Number) commandResult);
        }//from  w  w w  .  j a va 2 s  . c  om
        return result;
    }
    return response;
}

From source file:com.groupon.vertx.utils.config.VerticleConfig.java

License:Apache License

public VerticleConfig(String name, JsonObject deployConfig) {

    if (name == null) {
        throw new IllegalStateException("Field `name` not specified for verticle");
    }/*from  w  w w .  j a v  a2s  .  co m*/

    if (deployConfig == null) {
        throw new IllegalStateException(String.format("Verticle %s config cannot be null", name));
    }

    this.name = name;
    final Object instancesAsObject = deployConfig.getValue("instances");
    if (instancesAsObject instanceof Integer) {
        instances = (Integer) instancesAsObject;
    } else if (instancesAsObject instanceof String) {
        instances = parseInstances((String) instancesAsObject);
    } else {
        throw new ClassCastException("Unsupported class type for 'instances'");
    }
    className = deployConfig.getString("class");
    config = deployConfig.getValue("config");
    isWorker = deployConfig.getBoolean("worker", false);
    isMultiThreaded = deployConfig.getBoolean("multiThreaded", false);

    JsonArray dependencyJson = deployConfig.getJsonArray("dependencies");
    if (dependencyJson != null) {
        dependencies = new HashSet<>(dependencyJson.size());
        for (Object dep : dependencyJson) {
            if (dep instanceof String) {
                dependencies.add((String) dep);
            }
        }
    } else {
        dependencies = Collections.emptySet();
    }

    if (instances < 1) {
        throw new IllegalStateException(
                String.format("Field `instances` not specified or less than 1 for verticle %s", name));
    }

    if (className == null) {
        throw new IllegalStateException(
                String.format("Field `className` not specified for for verticle %s", name));
    }
}

From source file:com.hpe.sw.cms.verticle.ApiVerticle.java

License:Apache License

/**
 * Handler to handle GET /images request. The response is a list of images
 *
 * @return//  w ww  . j  a v a 2 s  . c o  m
 */
private Handler<RoutingContext> imagesHandler() {
    return routingContext -> {
        String timestamp = routingContext.request().getParam("timestamp");
        String id = routingContext.request().getParam("id");
        String include = routingContext.request().getParam("include");
        JsonObject param = new JsonObject();
        if (timestamp != null) {
            param.put("timestamp", timestamp);
        }
        if (id != null) {
            param.put("imageid", id);
        }
        if (include != null) {
            param.put("include", include);
        }
        getVertx().eventBus().send(Events.GET_IMAGES.name(), param, event -> {
            if (event.succeeded() && event.result() != null) {
                Message msg = event.result();
                JsonArray updates = (JsonArray) msg.body();
                HttpServerResponse response = routingContext.response();
                if (updates.size() == 0) {
                    response.end("There is no image found.");
                } else {
                    response.end(updates.toString());
                }
            } else if (event.result() == null) {
                routingContext.response().setStatusCode(404).end("There is no image found.");
            } else {
                routingContext.response().setStatusCode(500).end("Server has error.");
            }
        });
    };
}

From source file:com.hpe.sw.cms.verticle.ApiVerticle.java

License:Apache License

/**
 * Handler to handle Docker Registry event
 *
 * @return handler context//from  www  .jav a  2 s . c o  m
 */
private Handler<RoutingContext> registryEventHandler() {
    return routingContext -> {
        JsonObject body = routingContext.getBodyAsJson();
        LOG.info("Docker Registry events received from {}", routingContext.request().getParam("registry"));
        JsonArray events = body.getJsonArray("events");
        JsonArray updated = new JsonArray();
        JsonArray deleted = new JsonArray();
        events.forEach(e -> {
            JsonObject event = (JsonObject) e;
            if (event.getString("action").equals("push")) {
                JsonObject obj = createObj(event);
                if (obj != null) {
                    updated.add(obj);
                }
            } else if (event.getString("action").equals("delete")) {
                JsonObject obj = createObj(event);
                if (obj != null) {
                    deleted.add(obj);
                }
            }
        });
        if (updated.size() != 0)
            vertx.eventBus().publish(Events.EVENT_IMAGES_UPDATED.name(), updated);
        if (deleted.size() != 0) //TODO
            vertx.eventBus().publish(Events.EVENT_IMAGES_DELETED.name(), deleted);
        //Always return 200 OK.
        routingContext.response().setStatusCode(200).end("OK");

    };
}

From source file:com.hpe.sw.cms.verticle.MongoStoreVerticle.java

License:Apache License

@Override
public void start() throws Exception {
    super.start();
    client = MongoClient.createShared(vertx, config().getJsonObject("mongo"));
    vertx.eventBus().consumer(Events.GET_IMAGES.name(), msg -> {
        JsonObject param = (JsonObject) msg.body();
        JsonObject query = new JsonObject();
        if (param != null && param.getString("timestamp") != null) {
            Long timestamp = Long.parseLong(param.getString("timestamp"));
            query.put(Image.TIMESTAMP, new JsonObject().put("$gte", timestamp));
        } else if (param != null && param.getString("imageid") != null) {
            query.put(Image.IMAGE_ID, param.getString(Image.IMAGE_ID));
        }//w ww. j  a va 2  s.co  m

        if (!query.containsKey(Image.IMAGE_ID) && (param == null || param.getString("include") == null
                || !"all".equals(param.getString("include")))) {
            query.put(Image.IMAGE_ID, new JsonObject().put("$exists", true));
        }
        JsonArray images = new JsonArray();
        client.find("images", query, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                for (JsonObject dbImage : result) {
                    images.add(Image.cloneImage(dbImage));
                }
                msg.reply(images);
            }
        });
    });

    vertx.eventBus().consumer(Events.DOWNLOAD_FILE.name(), msg -> {
        JsonObject query = (JsonObject) msg.body();
        LOG.debug("DOWNLOAD_FILE query is " + query);
        client.find("images", query, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                LOG.debug("DOWNLOAD_FILE result is " + result.size());
                if (result.size() > 0) {
                    msg.reply(result.get(0));
                } else {
                    msg.reply(null);
                }
            }
        });
    });

    vertx.eventBus().consumer(Events.IMAGES_UPDATED.name(), msg -> {
        JsonArray updates = new JsonArray();
        JsonObject query = new JsonObject();
        query.put(Image.IS_SCANNED, false);
        int fetchSize = Integer.valueOf(String.valueOf(msg.body()));
        FindOptions options = new FindOptions();
        JsonObject sort = new JsonObject();
        sort.put(Image.TIMESTAMP, -1);
        options.setLimit(fetchSize).setSort(sort);
        client.findWithOptions("images", query, options, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                for (JsonObject update : result) {
                    updates.add(update);
                    LOG.debug("get image from DB :" + Image.getImageKey(update));
                }
                LOG.debug("IMAGES_UPDATED reply updates size " + updates.size());
                msg.reply(updates);
            }
        });
    });

    vertx.eventBus().consumer(Events.SCANFILE_UPLOADED.name(), msg -> {
        JsonObject upFile = (JsonObject) msg.body();
        JsonObject query = new JsonObject();
        query.put(Image.HOST, upFile.getString(Image.HOST)).put(Image.NAME, upFile.getString(Image.NAME))
                .put(Image.TAG, upFile.getString(Image.TAG));
        client.find("images", query, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                if (result.size() == 0) {
                    LOG.error("no mapped image in DB for " + Image.getImageKey(upFile));
                    return;
                }
                for (JsonObject dbImage : result) {
                    if (upFile.getBoolean("isScanFailed")) {
                        //Failed in scanning.
                        LOG.info("store failed scan to DB " + Image.getImageKey(upFile));
                        dbImage.put(Image.IS_SCANNED, true);
                        dbImage.put(Image.IS_SCANNED_FAILED, true);
                    } else {
                        //successfully in scanning.
                        LOG.info("store scanfile to DB " + Image.getImageKey(upFile));
                        dbImage.put(Image.IS_SCANNED, true);
                        dbImage.put(Image.IS_SCANNED_FAILED, false);
                        dbImage.put(Image.IMAGE_ID, upFile.getString(Image.IMAGE_ID));
                        dbImage.put(Image.SCANNED_FILE, upFile.getBinary(Image.SCANNED_FILE));
                    }
                    client.save("images", dbImage, h -> {
                        if (h.succeeded()) {
                            LOG.info("SCANFILE_UPLOADED:Image " + Image.getImageKey(dbImage) + " updated !");
                        } else {
                            h.cause().printStackTrace();
                        }
                    });
                }
            }
        });

    });

    vertx.eventBus().consumer(Events.ENRICHFILE_UPLOADED.name(), msg -> {
        JsonArray upFiles = (JsonArray) msg.body();
        for (Object upFileObj : upFiles) {
            JsonObject upFile = (JsonObject) upFileObj;
            if (upFile.getBinary("enrichedFile") == null) {
                LOG.info("enrichedFile is emptry for " + upFile.getString("imageid"));
                continue;
            }
            LOG.info("store enrichfile to DB " + upFile.getString("imageid"));
            JsonObject query = new JsonObject();
            query.put(Image.IMAGE_ID, upFile.getString(Image.IMAGE_ID));
            client.find("images", query, res -> {
                if (res.succeeded()) {
                    List<JsonObject> result = res.result();
                    for (JsonObject dbImage : result) {
                        dbImage.put(Image.IS_ENRICHED, true);
                        dbImage.put(Image.ENRICHED_FILE, upFile.getBinary(Image.ENRICHED_FILE));
                        client.save("images", dbImage, h -> {
                            if (h.succeeded()) {
                                LOG.info("ENRICHFILE_UPLOADED:Image " + Image.getImageKey(dbImage)
                                        + " updated !");
                            } else {
                                h.cause().printStackTrace();
                            }
                        });
                    }
                }
            });
        }

    });

    vertx.eventBus().consumer(Events.IMAGE_TO_ENRICH.name(), msg -> {
        JsonObject query = new JsonObject();
        query.put(Image.IS_SCANNED, true).put(Image.IS_SCANNED_FAILED, false).put(Image.IS_ENRICHED, false);
        client.find("images", query, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                msg.reply(new JsonArray(result));
            }
        });
    });

    vertx.eventBus().consumer(Events.NEW_IMAGE.name(), msg -> {
        //to store events in
        JsonObject obj = (JsonObject) msg.body();
        JsonObject query = new JsonObject();
        query.put(Image.HOST, obj.getString(Image.HOST)).put(Image.NAME, obj.getString(Image.NAME))
                .put(Image.TAG, obj.getString(Image.TAG));
        client.find("images", query, res -> {
            if (res.succeeded()) {
                List<JsonObject> result = res.result();
                if (result.isEmpty()) {
                    //inserted
                    client.insert("images", obj, h -> {
                        if (h.succeeded()) {
                            LOG.info("IMAGES_COMMING :Image " + Image.getImageKey(obj) + " inserted !");
                        } else {
                            h.cause().printStackTrace();
                        }
                    });
                } else if (result.size() == 1) {
                    JsonObject toUpdate = result.get(0);
                    if (!obj.getString(Image.SIGN).equals(toUpdate.getString(Image.SIGN))) {
                        toUpdate.put(Image.TIMESTAMP, obj.getLong(Image.TIMESTAMP))
                                .put(Image.SIGN, obj.getString(Image.SIGN))
                                .put(Image.IS_SCANNED, obj.getBoolean(Image.IS_SCANNED))
                                .put(Image.IS_ENRICHED, obj.getBoolean(Image.IS_ENRICHED));
                        //saved
                        client.save("images", toUpdate, h -> {
                            if (h.succeeded()) {
                                LOG.info("IMAGES_COMMING :Image " + Image.getImageKey(obj) + " updated !");
                            } else {
                                h.cause().printStackTrace();
                            }
                        });
                    } else {
                        LOG.info("IMAGES_COMMING :Image " + Image.getImageKey(obj)
                                + " has the same sign with the coming image, so will not update to DB !");
                    }
                } else {
                    throw new RuntimeException(
                            "IMAGES_COMMING :Found " + result.size() + " image for " + Image.getImageKey(obj));
                }
            }
        });
    });
}

From source file:com.hpe.sw.cms.verticle.RecognizerVerticle.java

License:Apache License

@Override
public void start() throws Exception {
    super.start();
    getVertx().setPeriodic(config().getLong("recognizer.interval", INTERVAL), h -> {
        getVertx().eventBus().send(Events.IMAGE_TO_ENRICH.name(), null, event -> {
            Message msg = event.result();
            if (msg != null) {
                String enrichPath = Constant.PROJECT_PATH + "xmlenricher/runtime/xmlenricher/Scans/incoming/";
                JsonArray scanfiles = (JsonArray) msg.body();
                for (Object obj : scanfiles) {
                    FileOutputStream fop = null;
                    try {
                        JsonObject image = (JsonObject) obj;
                        String filePath = enrichPath + image.getString("imageid") + ".xsf";
                        File file = new File(filePath);
                        if (!file.exists()) {
                            file.createNewFile();
                        }/*  w w  w. j  av  a2 s . co m*/
                        fop = new FileOutputStream(file);
                        IOUtils.write(image.getBinary("scannedFile"), fop);
                        fop.flush();
                        fop.close();
                    } catch (Exception e) {
                        LOG.error("Error in writing scan file", e);
                    } finally {
                        if (fop != null) {
                            try {
                                fop.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        });
    });

    //check whether there are new enriched files
    getVertx().setPeriodic(config().getLong("recognizer.interval", INTERVAL), h -> {
        String enrichPath = Constant.PROJECT_PATH + "xmlenricher/runtime/xmlenricher/Scans/processedcore/";
        File fileDir = new File(enrichPath);
        File[] fileList = fileDir.listFiles(XSF_FILTER);
        JsonArray enrichedFiles = new JsonArray();
        for (File file : fileList) {
            if (file.isFile()) {
                String imageid = file.getName().split("\\.")[0];
                try {
                    JsonObject enrichedFile = new JsonObject();
                    enrichedFile.put("imageid", imageid);
                    enrichedFile.put("enrichedFile", FileUtils.readFileToByteArray(file));
                    enrichedFiles.add(enrichedFile);
                    file.delete(); //TODO: do a batch delete after all enrichedFiles are collected
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (enrichedFiles.size() > 0) {
            getVertx().eventBus().publish(Events.ENRICHFILE_UPLOADED.name(), enrichedFiles);
        }
    });
}

From source file:com.hpe.sw.cms.verticle.WatcherVerticle.java

License:Apache License

@Override
public void start() throws Exception {
    httpClient = vertx.createHttpClient();
    getVertx().setPeriodic(config().getLong("registry.interval", INTERVAL), this::handler);
    vertx.eventBus().consumer(Events.EVENT_IMAGES_UPDATED.name(), msg -> {
        JsonArray images = (JsonArray) msg.body();
        if (images.size() > 0) {
            for (Object image : images) {
                JsonObject imageObj = (JsonObject) image;
                try {
                    String url = imageObj.getString("eventUrl");
                    httpClient.getAbs(url, new Handler<HttpClientResponse>() {
                        @Override
                        public void handle(HttpClientResponse httpClientResponse) {
                            httpClientResponse.bodyHandler(new Handler<Buffer>() {
                                @Override
                                public void handle(Buffer buffer) {
                                    JsonObject maniFestLib = buffer.toJsonObject();
                                    String tag = maniFestLib.getString("tag");
                                    LOG.debug("populateTagToImage " + tag);
                                    imageObj.put(Image.TAG, tag);
                                    populateAndSendImage(imageObj);
                                }/*from w  w w.j  a v a2  s.  co  m*/
                            });
                        }
                    }).end();

                } catch (Exception e) {
                    LOG.error("error in populateTagToImage", e);
                }
            }

        }
    });
}

From source file:com.hpe.sw.cms.verticle.WatcherVerticle.java

License:Apache License

private void populateAndSendImage(JsonObject imageObj) {
    try {//from w ww . j a  v a 2  s . co  m
        String protocol = config().getString("registry.protocol");
        String host = config().getString("registry.host");
        httpClient.getAbs(protocol + host + "/v2/" + imageObj.getString("name") + "/manifests/"
                + imageObj.getString("tag"), new Handler<HttpClientResponse>() {
                    @Override
                    public void handle(HttpClientResponse httpClientResponse) {
                        httpClientResponse.bodyHandler(new Handler<Buffer>() {
                            @Override
                            public void handle(Buffer buffer) {
                                JsonObject maniFestLib = buffer.toJsonObject();
                                JsonArray signs = maniFestLib.getJsonArray("signatures");
                                if (signs != null && signs.size() > 0) {
                                    StringBuffer fullSign = new StringBuffer();
                                    for (Object sign : signs.getList()) {
                                        fullSign.append(((Map) sign).get("signature")).append("|");
                                    }
                                    imageObj.put(Image.SIGN, fullSign);
                                    imageObj.put(Image.IS_SCANNED, false);
                                    imageObj.put(Image.IS_ENRICHED, false);
                                    imageObj.put(Image.IS_SCANNED_FAILED, false);
                                    if (imageObj.getLong(Image.TIMESTAMP) == null) {
                                        imageObj.put(Image.TIMESTAMP, new Date().getTime());
                                    }
                                    vertx.eventBus().publish(Events.NEW_IMAGE.name(), imageObj);
                                    LOG.info("Event Image with populateSignToImage", imageObj);
                                }
                            }
                        });
                    }
                }).end();
    } catch (Exception e) {
        LOG.error("error in populateSignToImage", e);
    }
}