Example usage for io.vertx.core.json JsonObject getString

List of usage examples for io.vertx.core.json JsonObject getString

  1. HOME
  2. Java
  3. io.vertx
  4. io.vertx.core.json.*
  5. JsonObject
  6. getString

Introduction

In this page you can find the example usage for io.vertx.core.json JsonObject getString.

Prototype

public String getString(String key)

Source Link

Document

Get the string value with the specified key, special cases are addressed for extended JSON types Instant , byte[] and Enum which can be converted to String.

Usage

From source file:com.cyngn.vertx.bosun.BosunReporter.java

License:Apache License

/**
 * Setup our client connections/*from  ww w.  j  av a2 s  .c om*/
 *
 * @param startedResult the startup callback for loading the module
 */
private void initializeConnections(Future<Void> startedResult) {
    try {
        for (int i = 0; i < hosts.size(); i++) {
            JsonObject jsonHost = hosts.getJsonObject(i);
            connections.add(
                    vertx.createHttpClient(new HttpClientOptions().setDefaultHost(jsonHost.getString("host"))
                            .setDefaultPort(jsonHost.getInteger("port")).setKeepAlive(true).setTcpNoDelay(true)
                            .setConnectTimeout(timeout).setTryUseCompression(true)));
        }
    } catch (Exception ex) {
        startedResult.fail(ex.getLocalizedMessage());
        return;
    }
    // all connections added
    startedResult.complete();
}

From source file:com.cyngn.vertx.bosun.OpenTsDbMetric.java

License:Apache License

public OpenTsDbMetric(JsonObject obj) {
    if (obj == null) {
        throw new IllegalArgumentException("You must supply a non-null JsonObject");
    }//  www. j  a va 2 s .  c  o  m

    this.metric = obj.getString(METRIC_FIELD);
    this.value = obj.getValue(VALUE_FIELD);
    this.tags = obj.getJsonObject(TAGS_FIELD);
    timestamp = System.currentTimeMillis();
    validateObj();
}

From source file:com.cyngn.vertx.opentsdb.service.OpenTsDbService.java

License:Apache License

private void initializeWorkers(Future<Void> startedResult) {
    final AtomicInteger count = new AtomicInteger();
    processor = new MetricsProcessor(workers, options.getMaxBufferBytes(), vertx.eventBus());
    JsonArray hosts = options.getHosts();
    for (int i = 0; i < hosts.size(); i++) {
        JsonObject jsonHost = hosts.getJsonObject(i);

        // we setup one worker dedicated to each endpoint, the same worker always rights to the same outbound socket
        OpenTsDbClient worker = new OpenTsDbClient(jsonHost.getString("host"), jsonHost.getInteger("port"),
                vertx, success -> {//from   w  w w .j  a  v a 2  s  .c  om
                    if (!success) {
                        String error = String.format("Failed to connect to host: %s", jsonHost.encode());
                        logger.error(error);
                        vertx.close();
                        startedResult.fail(error);
                        return;
                    }

                    count.incrementAndGet();
                    if (count.get() == hosts.size()) {
                        flushTimerId = vertx.setPeriodic(options.getFlushInterval(),
                                timerId -> processor.processMetrics(metrics));
                        logger.info(options);
                        startReporter();
                        startedResult.complete();
                    }
                });
        workers.add(worker);
    }
}

From source file:com.cyngn.vertx.opentsdb.Util.java

License:Apache License

/**
 * Take config specified tags and make a OpenTsDb tag string
 *
 * @param tags the map of tags to convert to their string form
 * @return list of tags in opentsdb format ie 'name1=value1 name2=value2'
 *//*from   www.j  av a2s  .c  o  m*/
public static String createTagsFromJson(JsonObject tags) {
    String tagsString = "";
    if (tags != null && tags.size() > 0) {
        StringBuilder builder = new StringBuilder();
        for (String key : tags.fieldNames()) {
            builder.append(key).append("=").append(tags.getString(key)).append(" ");
        }
        // if necessary, grab all but the last character, since it's always a space
        if (builder.length() > 0) {
            tagsString = builder.substring(0, builder.length() - 1);
        } else {
            tagsString = builder.toString();
        }
    }

    return tagsString;
}

From source file:com.ddp.SimpleREST.java

License:Open Source License

private static void initConfig(JsonObject js) {
    httpPort = js.getInteger("http.port");
    sqlDriverClass = js.getString("driver.class");
    sqlUrl = js.getString("sql.url");
    localUploadHome = js.getString("local.upload.home");
    hdfsUploadHome = js.getString("hdfs.upload.home");
    toScheduleEvent = js.getString("eventbus.schedverticle");
}

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

License:Apache License

/**
 * Start the verticle/*  w  ww . jav a2 s . c o  m*/
 *
 * @param startFuture
 * @throws Exception
 */
public void start(Future<Void> startFuture) throws Exception {

    logger.info("starup with config: " + config().toString());

    // get expire_release in seconds
    int expire_timeout = config().getInteger("expire_timeout", 86000);

    // map of releases, should contain date events were fired in  / updated also
    releasesData = new HashMap<>();

    stateFile = config().getString("state_file", "/state.json");

    // connect to the eventbus
    eb = vertx.eventBus();

    // load the state file if exists
    vertx.fileSystem().exists(stateFile, h -> {
        if (h.succeeded()) {
            try {
                JsonArray history = Util.loadConfig(stateFile).getJsonArray("releases");
                for (Object release : history) {
                    JsonObject releaseJson = new JsonObject(release.toString());
                    logger.info("loading release: " + releaseJson.getString("id"));
                    releasesData.put(releaseJson.getString("id"), releaseJson.getJsonObject("data"));
                }

            } catch (IOException e) {
                logger.warn("unable to load state file, it will be created / overwritten");
                e.printStackTrace();
            }

        }
    });

    /*
     * listen for release events from other verticles / clients
     *
     * example release-event published direct to the eventbus ( see Server.java )
     *
            
      {
          "code": 205,
          "component": "maximus",
          "environment": "CI1",
          "status": "Deploy Succeeded",
          "version": "1.0.0.309"
      }
            
     *
     *
     */
    eb.consumer("release-event", event -> {
        logger.info(event.body().toString());

        JsonObject body = null;

        // create a json object from the message
        try {
            body = new JsonObject(event.body().toString());
        } catch (Exception e) {
            logger.warn("not a json object");
            event.reply(new JsonObject().put("result", "failure").put("reason", "that wasn't json"));
        }

        // create check if a id is specified, else combine component and version
        body.put("id", body.getString("id", body.getValue("component") + "-" + body.getValue("version")));

        // used for marking expired messages when time is not enough or too much
        body.put("expired", false);

        // add the date now
        body.put("date", LocalDateTime.now().format(formatter));

        // pop the old matching JIRA release
        releasesData.remove(body.getString("id"));

        // put the updated one
        releasesData.put(body.getString("id"), body);

        event.reply(new JsonObject().put("result", "success"));

    });

    // expire a release event and remove it from the map
    eb.consumer("expire-release-event", event -> {
        try {
            logger.info("delete event: " + event.body().toString());
            JsonObject request = new JsonObject(event.body().toString());
            releasesData.remove(request.getString("id"));

            // forulate the expire message
            JsonObject msg = new JsonObject().put("topic", "releases").put("action", "expire");
            JsonArray arr = new JsonArray().add(request.getString("id"));
            msg.put("data", arr);

            eb.publish("releases", msg);

            event.reply(new JsonObject().put("result", "success"));
        } catch (Exception e) {
            event.reply(new JsonObject().put("result", "error"));
        }
    });

    vertx.setPeriodic(10000, tid -> {

        JsonObject msg = new JsonObject();
        msg.put("topic", "releases");
        msg.put("action", "default");

        JsonArray rel = new JsonArray();

        Iterator<Map.Entry<String, JsonObject>> iter = releasesData.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry<String, JsonObject> entry = iter.next();
            rel.add(entry.getValue());
        }

        msg.put("data", rel);

        eb.publish("releases", msg);

    });

    // periodically expire old releases in the map
    vertx.setPeriodic(config().getInteger("check_expiry", 1000), res -> {
        // iterate over map, check dates for each, expire as needed

        Iterator<Map.Entry<String, JsonObject>> iter = releasesData.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry<String, JsonObject> entry = iter.next();

            logger.debug("checking expiry on " + entry.getKey() + " v " + entry.getValue());

            // now
            LocalDateTime now = LocalDateTime.now();

            // then
            LocalDateTime then = LocalDateTime.parse(entry.getValue().getString("date"), formatter);

            // delta
            Long delta = now.toEpochSecond(ZoneOffset.UTC) - then.toEpochSecond(ZoneOffset.UTC);

            if (delta >= expire_timeout) {
                logger.info("expiring stale release: " + entry.getValue() + " delta: " + delta.toString());
                iter.remove();
            }

        }

    });

    // save the current pile of releases into a JSON periodically
    vertx.setPeriodic(config().getInteger("save_interval", 60000), t -> {
        saveState();
    });

    startFuture.complete();

}

From source file:com.deblox.server.MockServer.java

License:Apache License

@Override
public void start(Future<Void> startFuture) {
    logger.info("starting with config: " + config().toString());
    Router router = Router.router(vertx);

    try {//from www .j  a  v a2 s.  c o  m
        serverConfig = Util.loadConfig(config().getString("serverConfig", "/conf.json")).getJsonObject(
                config().getString("serverVerticle", "com.deblox.solacemonitor.MonitorVerticle"));
        metrics = serverConfig.getJsonObject("config").getJsonObject("metrics");
        logger.info("metrics: " + metrics);
    } catch (IOException e) {
        e.printStackTrace();
    }

    router.route().handler(CorsHandler.create("*").allowedMethod(HttpMethod.GET).allowedMethod(HttpMethod.POST)
            .allowedMethod(HttpMethod.OPTIONS).allowedHeader("Content-Type"));

    router.get("/SEMP").handler(ctx -> {
        logger.debug("mock server taking request");
        ctx.response().setChunked(true);
        ctx.response().write("POST YOUR SEMP REQUESTS HERE");
        ctx.response().end();
    });

    /*
            
    accepts XML posted to /SEMP,
    matches XML against metrics's request string in serverConfig's metrics object
    reads a XML file from resources matching the NAME of the metric e.g. stats
            
     */

    router.post("/SEMP").handler(ctx -> {
        logger.debug("mock server taking request");

        for (Map.Entry<String, String> entry : ctx.request().headers()) {
            logger.debug("Header: " + entry.getKey() + " : " + entry.getValue());
        }

        ctx.request().bodyHandler(body -> {
            logger.debug("Body Handler");
            logger.debug(body.toString());

            logger.debug("Matching metrics:");

            metrics.forEach(e -> {
                logger.debug(e.getKey());

                JsonObject j = (JsonObject) e.getValue();

                try {

                    if (j.getString("request").equals(body.toString())) {
                        logger.debug("MATCHED");

                        ctx.response().setChunked(true);
                        try {
                            ctx.response().sendFile("mock/" + e.getKey() + ".xml");
                        } catch (Exception x) {
                            x.printStackTrace();
                        }

                    }
                } catch (Exception x) {
                    logger.warn("skipping " + j.toString());
                }

                logger.debug(j.getString("request"));

            });

        });

    });

    // the server itself
    vertx.createHttpServer().requestHandler(router::accept).listen(config().getInteger("port", 8081));

    // send back deployment complete
    startFuture.complete();
}

From source file:com.deblox.solacemonitor.MonitorVerticle.java

License:Apache License

/**
 * Start the verticle/*from   w  w  w . jav a 2s.c o m*/
 *
 * @param startFuture
 * @throws Exception
 */
public void start(Future<Void> startFuture) throws Exception {

    logger.info("starup with config: " + config().toString());

    // read startup config
    config = config();

    // vars
    host = config.getString("host", null);
    port = config.getInteger("port", 80);
    uri = config.getString("uri", "/");
    username = config.getString("username", "DEFAULT_USERNAME");
    password = config.getString("password", "DEFAULT_PASSWORD");
    credentials = String.format("%s:%s", username, password);
    method = config.getString("method", "GET");

    // map for connected clients
    clients = new HashMap<UUID, String>();

    // generate a uuid
    uuid = UUID.randomUUID().toString();

    // connect to the eventbus
    eb = vertx.eventBus();

    // create a instance of http client
    client = vertx.createHttpClient();

    // eventbus ping listner
    eb.consumer("ping-address", message -> {
        logger.info(uuid + ": replying");
        message.reply("pong!");
    });

    // handler for requests for metrics
    eb.consumer("request-metrics", message -> {
        logger.info(uuid + ": requesting metrics");

        try {
            getRest(message.body().toString(), event -> {
                logger.debug("response: " + event.toString());
                if (config().getBoolean("convert_xml_response_to_json", false)) {
                    message.reply(Util.xml2json(event.toString()));
                } else {
                    message.reply(event.toString());
                }
            });
        } catch (Exception e) {
            logger.warn("unable to get metric");
            e.printStackTrace();
        }

    });

    // returns a array of names for all metrics defined in config
    // used for setting up the client
    eb.consumer("request-config", message -> {

        String req = message.body().toString();

        logger.debug("config request for: " + req);

        JsonObject response = new JsonObject();

        // all = return a list of metrics
        if (req.equals("all")) {

            JsonArray results = new JsonArray(config.getJsonObject("metrics").stream()
                    .filter(r -> ((JsonObject) r.getValue()).getBoolean("show_in_menu", true))
                    .map(r -> r.getKey()).sorted().collect(Collectors.toList()));
            response.put("metrics", results);

        } else {
            // get a specific metric's config
            response = config.getJsonObject("metrics").getJsonObject(req);
            response.put("topic", req);
            logger.debug(response.toString());

        }

        message.reply(response);

    });

    // register new clients
    eb.consumer("newclient", message -> {
        logger.info("new client: " + message.body().toString());
        JsonObject client = new JsonObject(message.body().toString());
        clients.remove(client.getString("uuid"));
        clients.put(UUID.fromString(client.getString("uuid")), client.getString("version"));
    });

    // client ping maintains the clients map
    eb.consumer("client-ping", message -> {
        JsonObject client = new JsonObject(message.body().toString());
        clients.remove(client.getString("uuid"));
        clients.put(UUID.fromString(client.getString("uuid")), client.getString("version"));
    });

    // listen for broadcasts from other verticles / clients
    eb.consumer("broadcast", event -> {
        logger.info(event.body().toString());
        JsonObject message = new JsonObject(event.body().toString());
        broadcast(message.getString("topic", "unknown"), event.body().toString());
    });

    // create metric emitters
    Iterator iter = config.getJsonObject("metrics", new JsonObject()).iterator();
    while (iter.hasNext()) {

        Map.Entry<String, JsonObject> metricConfig = (Map.Entry) iter.next();

        logger.debug("registering metric: " + metricConfig.getKey());

        int interval = metricConfig.getValue().getInteger("interval", 0);

        if (interval != 0) {
            vertx.setPeriodic(interval, tid -> {

                logger.debug("metric interval handler for " + metricConfig.getKey() + " every " + interval);

                try {

                    getRest(metricConfig.getKey(), event -> {
                        logger.debug("metric: " + event.toString());

                        JsonObject metricMessage = new JsonObject();
                        metricMessage.put("topic", metricConfig.getKey());
                        metricMessage.put("data", Util.xml2json(event.toString()));

                        // get the config for the metric
                        JsonObject msgConfig = config.getJsonObject("metrics")
                                .getJsonObject(metricConfig.getKey()).getJsonObject("config", new JsonObject());

                        // get the view_format by name
                        msgConfig.put("view_format", config.getJsonObject("views", new JsonObject())
                                .getJsonObject(msgConfig.getString("view", "default")));

                        // put the config into the message
                        metricMessage.put("config", msgConfig);

                        // publish the metric
                        eb.publish(metricConfig.getKey(), metricMessage);

                    });
                } catch (Exception e) {
                    logger.warn("unable to publish metric");
                    e.printStackTrace();
                }
            });

        } else {
            logger.warn("metric " + metricConfig.getKey() + " is disabled ");

        }
    }

    // after 10 seconds, announce the server version to all clients
    vertx.setTimer(10000, tid -> {
        broadcast("broadcast", "Server Startup " + config.getString("version", server_version));
    });

    // after 10 seconds, announce the server version to all clients
    vertx.setPeriodic(1000, tping -> {
        eb.publish("ping", new JsonObject().put("data", "ping"));
    });

    // periodically nuke all the client sessions
    vertx.setPeriodic(config().getInteger("client_session_refresh", 300000), res -> {
        clients = new HashMap<UUID, String>();
    });

    // periodically log number of clients in the map
    vertx.setPeriodic(config().getInteger("client_session_show", 180000), res -> {
        logger.info(clients.size() + " connected clients");
    });

    startFuture.complete();

}

From source file:com.funmix.service.DriverServiceImpl.java

@Override
public Future<JsonObject> getAll(JsonObject params) {
    Future<JsonObject> result = Future.future();
    StringBuffer sqlCount = new StringBuffer(SQL_QUERY_COUNT);
    StringBuffer sqlQuery = new StringBuffer(SQL_QUERY_ALL);
    StringBuffer order = new StringBuffer();
    StringBuffer where = new StringBuffer();
    JsonArray queryparams = new JsonArray();
    JsonArray countparams = new JsonArray();
    params.forEach(r -> {//from   w ww . j a  va  2s. c  o  m
        String key = r.getKey();
        if (key.equals("orderby")) {
            order.append(" order by ").append(r.getValue());
        } else if (key.equals("page")) {
        } else if (key.equals("page_size")) {
        } else {
            if (where.length() == 0)
                where.append(" where ");
            else
                where.append(" and ");
            where.append(key).append(" like ? ");
            queryparams.add("%" + r.getValue() + "%");
            countparams.add("%" + r.getValue() + "%");
        }
    });

    if (where.length() > 0) {
        sqlCount.append(where);
        sqlQuery.append(where);
    }
    JsonObject jrs = new JsonObject();
    client.getConnection(connHandler(result, connection -> {
        log.info(sqlCount);
        if (countparams.size() == 0)
            connection.query(sqlCount.toString(), r -> {
                if (r.failed()) {
                    result.fail(r.cause());
                } else {
                    int count = r.result().getRows().get(0).getInteger("count");
                    jrs.put("total", count);
                }
            });
        else
            connection.queryWithParams(sqlCount.toString(), countparams, r -> {
                if (r.failed()) {
                    result.fail(r.cause());
                } else {
                    int count = r.result().getRows().get(0).getInteger("count");
                    jrs.put("total", count);
                }
            });
        if (order.length() > 0) {
            sqlQuery.append(order);
            queryparams.add(params.getString("orderby"));
        }
        if (params.getValue("page") == null) {
            params.put("page", "0");
            params.put("page_size", "" + Integer.MAX_VALUE);
        }
        sqlQuery.append(" limit ?,? ");
        log.info(sqlQuery);
        int page = Integer.parseInt(params.getString("page"));
        int limit = Integer.parseInt(params.getString("page_size"));
        queryparams.add(Utils.calcPage(page, limit)).add(limit);
        connection.queryWithParams(sqlQuery.toString(), queryparams, r -> {
            if (r.failed()) {
                result.fail(r.cause());
            } else {
                jrs.put("data", r.result().getRows().stream().map(Driver::new).collect(Collectors.toList()));
                jrs.put("per_page", limit);
                jrs.put("current_page", page);
            }
            result.complete(new JsonObject().put("status", 200).put("data", new JsonObject().put("list", jrs)));
        });
        connection.close();

    }));
    return result;
}

From source file:com.funmix.service.DriverServiceImpl.java

@Override
public Future<Optional<Driver>> insert(JsonObject json) {
    Future<Optional<Driver>> result = Future.future();
    JsonArray params = new JsonArray();
    //username,email,phone,driverlicense,memo,status
    params.add(json.getString("username"));
    params.add(json.getString("email"));
    params.add(json.getString("phone"));
    params.add(json.getString("driverlicense"));
    params.add(json.getString("memo"));
    params.add(json.getString("status"));
    client.getConnection(connHandler(result, connection -> {
        connection.updateWithParams(SQL_INSERT, params, r -> {
            if (r.failed()) {
                result.fail(r.cause());/*from  w  w  w  . j  a va2  s. c o m*/
            } else {
                UpdateResult urs = r.result();
                params.clear();
                params.add(urs.getKeys().getInteger(0));
                log.info(urs.getKeys().getInteger(0));
                connection.queryWithParams(SQL_QUERY, params, rs -> {
                    if (rs.failed()) {
                        result.fail(rs.cause());
                        log.info(rs.cause());
                    } else {
                        List<JsonObject> list = rs.result().getRows();
                        if (list == null || list.isEmpty()) {
                            result.complete(Optional.empty());
                        } else {
                            result.complete(Optional.of(new Driver(list.get(0))));
                        }
                    }
                });
            }
            connection.close();
        });
    }));
    return result;
}