io.javalin.Context Java Examples

@Override
public void handle(Context context) {
    try {
        List<Report> reports = reportDao.fetchAllAggregated();

        context.json(reports);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        if (report != null) {
            context.json(report);
        }
        else {
            context.status(404);
        }
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }


}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        LatencyStatisticsResponse response = new LatencyStatisticsResponse();

        processReports(report, response);

        context.json(response);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }


}
 

@Override
public void handle(Context context) {
    try {
        int testId = Integer.parseInt(context.param("id"));
        int testNumber = Integer.parseInt(context.param("number"));

        Report report = reportDao.fetchAggregated(testId, testNumber);

        LatencyStatisticsResponse response = new LatencyStatisticsResponse();

        processReports(report, response);

        context.json(response);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }


}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        SingleData<Long> rateData = processReport(report, report.getTestHostRole());

        RateResponse rateResponse = new RateResponse();
        rateResponse.setPeriods(rateData.getPeriods());
        rateResponse.setRate(rateData.getValues());

        context.json(rateResponse);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int testId = Integer.parseInt(
                Objects.requireNonNull(context.param("id"), "The ID must be provided"));

        int testNumber = Integer.parseInt(
                Objects.requireNonNull(context.param("number"), "The test number must be provided"));

        Report report = reportDao.fetchAggregated(testId, testNumber);

        LatencyResponse response = new LatencyResponse();

        processReports(report, response);

        context.json(response);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        SingleData<Long> rateData = processReport(report, report.getTestHostRole());

        RateStatisticsResponse rateResponse = new RateStatisticsResponse();
        rateResponse.addStatistics(rateData.getStatistics());

        context.json(rateResponse);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        LatencyResponse response = new LatencyResponse();

        processReports(report, response);

        context.json(response);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int testId = Integer.parseInt(context.param("id"));
        int testNumber = Integer.parseInt(context.param("number"));
        String hostRole = context.param("role");

        Report report = reportDao.fetchAggregated(testId, testNumber);

        SingleData<Long> rateData = processReport(report, hostRole);

        RateStatisticsResponse rateResponse = new RateStatisticsResponse();
        rateResponse.addStatistics(rateData.getStatistics());

        context.json(rateResponse);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int testId = Integer.parseInt(context.param("test"));

        List<SutNodeInfo> sutNodeInfo = dao.fetchByTest(testId);

        context.json(sutNodeInfo);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));
        String name = context.param("name");

        Report report = reportDao.fetch(id);

        File file = getReportFile(report, name);

        context.result(new FileInputStream(file))
                .header("Content-Length: ", String.valueOf(FileUtils.sizeOf(file)))
                .header("Content-Type", "application/octet-stream");
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        List<Report> reports = reportDao.fetch();

        context.json(reports);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

/**
 * Syncs data-set view if local view is behind.
 */
private boolean syncIfLocalViewBehind(Context ctx) {
  if (isLocalViewBehind(ctx)) {
    String basePath = ctx.queryParam(RemoteHoodieTableFileSystemView.BASEPATH_PARAM);
    String lastKnownInstantFromClient =
        ctx.queryParam(RemoteHoodieTableFileSystemView.LAST_INSTANT_TS, HoodieTimeline.INVALID_INSTANT_TS);
    SyncableFileSystemView view = viewManager.getFileSystemView(basePath);
    synchronized (view) {
      if (isLocalViewBehind(ctx)) {
        HoodieTimeline localTimeline = viewManager.getFileSystemView(basePath).getTimeline();
        LOG.info("Syncing view as client passed last known instant " + lastKnownInstantFromClient
            + " as last known instant but server has the folling timeline :"
            + localTimeline.getInstants().collect(Collectors.toList()));
        view.sync();
        return true;
      }
    }
  }
  return false;
}
 

/**
 * Determines if local view of table's timeline is behind that of client's view.
 */
private boolean isLocalViewBehind(Context ctx) {
  String basePath = ctx.queryParam(RemoteHoodieTableFileSystemView.BASEPATH_PARAM);
  String lastKnownInstantFromClient =
      ctx.queryParam(RemoteHoodieTableFileSystemView.LAST_INSTANT_TS, HoodieTimeline.INVALID_INSTANT_TS);
  String timelineHashFromClient = ctx.queryParam(RemoteHoodieTableFileSystemView.TIMELINE_HASH, "");
  HoodieTimeline localTimeline =
      viewManager.getFileSystemView(basePath).getTimeline().filterCompletedAndCompactionInstants();
  if (LOG.isDebugEnabled()) {
    LOG.debug("Client [ LastTs=" + lastKnownInstantFromClient + ", TimelineHash=" + timelineHashFromClient
        + "], localTimeline=" + localTimeline.getInstants().collect(Collectors.toList()));
  }

  if ((localTimeline.getInstants().count() == 0)
      && HoodieTimeline.INVALID_INSTANT_TS.equals(lastKnownInstantFromClient)) {
    return false;
  }

  String localTimelineHash = localTimeline.getTimelineHash();
  if (!localTimelineHash.equals(timelineHashFromClient)) {
    return true;
  }

  // As a safety check, even if hash is same, ensure instant is present
  return !localTimeline.containsOrBeforeTimelineStarts(lastKnownInstantFromClient);
}
 

private void handleCumulativeLatencies(Context ctx) throws Exception {
    CumulativeLatencies stats = localWorker.getCumulativeLatencies();

    // Serialize histograms
    synchronized (histogramSerializationBuffer) {
        histogramSerializationBuffer.clear();
        stats.publishLatency.encodeIntoCompressedByteBuffer(histogramSerializationBuffer);
        stats.publishLatencyBytes = new byte[histogramSerializationBuffer.position()];
        histogramSerializationBuffer.flip();
        histogramSerializationBuffer.get(stats.publishLatencyBytes);

        histogramSerializationBuffer.clear();
        stats.endToEndLatency.encodeIntoCompressedByteBuffer(histogramSerializationBuffer);
        stats.endToEndLatencyBytes = new byte[histogramSerializationBuffer.position()];
        histogramSerializationBuffer.flip();
        histogramSerializationBuffer.get(stats.endToEndLatencyBytes);
    }

    ctx.result(writer.writeValueAsString(stats));
}
 

private void handleCreateConnector(Context context) {
    String connectorName = context.param("connectorName");
    String arg = context.queryParam("config");
    Map keyValue = JSON.parseObject(arg, Map.class);
    ConnectKeyValue configs = new ConnectKeyValue();
    for(Object key : keyValue.keySet()){
        configs.put((String)key, (String)keyValue.get(key));
    }
    try {

        String result = connectController.getConfigManagementService().putConnectorConfig(connectorName, configs);
        if(result != null && result.length() > 0){
            context.result(result);
        }else{
            context.result("success");
        }
    } catch (Exception e) {
        context.result("failed");
    }
}
 

private void handlePeriodStats(Context ctx) throws Exception {
    PeriodStats stats = localWorker.getPeriodStats();

    // Serialize histograms
    synchronized (histogramSerializationBuffer) {
        histogramSerializationBuffer.clear();
        stats.publishLatency.encodeIntoCompressedByteBuffer(histogramSerializationBuffer);
        stats.publishLatencyBytes = new byte[histogramSerializationBuffer.position()];
        histogramSerializationBuffer.flip();
        histogramSerializationBuffer.get(stats.publishLatencyBytes);

        histogramSerializationBuffer.clear();
        stats.endToEndLatency.encodeIntoCompressedByteBuffer(histogramSerializationBuffer);
        stats.endToEndLatencyBytes = new byte[histogramSerializationBuffer.position()];
        histogramSerializationBuffer.flip();
        histogramSerializationBuffer.get(stats.endToEndLatencyBytes);
    }

    ctx.result(writer.writeValueAsString(stats));
}
 

private void getAllocatedInfo(Context context){

        Set<WorkerConnector> workerConnectors = connectController.getWorker().getWorkingConnectors();
        Set<Runnable> workerSourceTasks = connectController.getWorker().getWorkingTasks();
        StringBuilder sb = new StringBuilder();
        sb.append("working connectors:\n");
        for(WorkerConnector workerConnector : workerConnectors){
            sb.append(workerConnector.toString()+"\n");
        }
        sb.append("working tasks:\n");
        for(Runnable runnable : workerSourceTasks){
            sb.append(runnable.toString()+"\n");
        }
        context.result(sb.toString());
    }
 

private void handleInitializeDriver(Context ctx) throws Exception {
    // Save config to temp file
    File tempFile = File.createTempFile("driver-configuration", "conf");
    Files.write(ctx.bodyAsBytes(), tempFile);

    localWorker.initializeDriver(tempFile);
    tempFile.delete();
}
 

private void handleStartLoad(Context ctx) throws Exception {
    ProducerWorkAssignment producerWorkAssignment = mapper.readValue(ctx.body(), ProducerWorkAssignment.class);

    log.info("Start load publish-rate: {} msg/s -- payload-size: {}", producerWorkAssignment.publishRate,
            producerWorkAssignment.payloadData.length);

    localWorker.startLoad(producerWorkAssignment);
}
 

private void writeValueAsString(Context ctx, Object obj) throws JsonProcessingException {
  boolean prettyPrint = ctx.queryParam("pretty") != null;
  long beginJsonTs = System.currentTimeMillis();
  String result =
      prettyPrint ? OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(obj) : OBJECT_MAPPER.writeValueAsString(obj);
  long endJsonTs = System.currentTimeMillis();
  LOG.debug("Jsonify TimeTaken=" + (endJsonTs - beginJsonTs));
  ctx.result(result);
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("id"));

        Report report = reportDao.fetch(id);

        String location = report.getLocation();
        File file = new File(location, "test.properties");

        TestProperties tp = new TestProperties();

        List<ExtendedTestProperties> testPropertiesList = new LinkedList<>();

        if (HostTypes.isWorker(report.getTestHostRole())) {
            PropertyReader reader = new PropertyReader();

            reader.read(file, tp);

            ExtendedTestProperties etp = new ExtendedTestProperties(tp);
            etp.setRole(report.getTestHostRole());
            testPropertiesList.add(etp);
            context.json(testPropertiesList);
        }
        else {
            context.status(500);
            context.result(String.format("Unhandled node type for the report: %s", report.getTestHostRole()));
        }
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        logger.error(t.getMessage(), t);
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int testId = Integer.parseInt(
                Objects.requireNonNull(context.param("id"), "The ID must be provided"));

        int testNumber = Integer.parseInt(
                Objects.requireNonNull(context.param("number"), "The test number must be provided"));

        String hostRole = context.param("role");

        Report report = reportDao.fetchAggregated(testId, testNumber);

        SingleData<Long> rateData = processReport(report, hostRole);

        RateResponse rateResponse = new RateResponse();
        rateResponse.setPeriods(rateData.getPeriods());
        rateResponse.setRate(rateData.getValues());

        context.json(rateResponse);
    }
    catch (DataNotFoundException e) {
        context.status(404);
        context.result(String.format("Not found: %s", e.getMessage()));
    }
    catch (Throwable t) {
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

@Override
public void handle(Context context) {
    try {
        int id = Integer.parseInt(context.param("test"));
        int number = Integer.parseInt(context.param("number"));

        List<Report> reports = reportDao.fetch(id, number);
        List<ExtendedTestProperties> testPropertiesList = new LinkedList<>();

        for (Report report : reports) {
            String location = report.getLocation();
            File file = new File(location, "test.properties");

            TestProperties tp = new TestProperties();

            if (HostTypes.isWorker(report.getTestHostRole())) {
                PropertyReader reader = new PropertyReader();

                reader.read(file, tp);

                ExtendedTestProperties etp = new ExtendedTestProperties(tp);

                etp.setRole(report.getTestHostRole());
                testPropertiesList.add(etp);
            }
        }

        context.json(testPropertiesList);
    }
    catch (Throwable t) {
        logger.error(t.getMessage(), t);
        context.status(500);
        context.result(String.format("Internal server error: %s", t.getMessage()));
    }
}
 

private void handleStopConnector(Context context){
    String connectorName = context.param("connectorName");
    try {

        connectController.getConfigManagementService().removeConnectorConfig(connectorName);
        context.result("success");
    } catch (Exception e) {
        context.result("failed");
    }
}
 

private void handleQueryConnectorStatus(Context context){

        String connectorName = context.param("connectorName");
        Map<String, ConnectKeyValue> connectorConfigs = connectController.getConfigManagementService().getConnectorConfigs();

        if(connectorConfigs.containsKey(connectorName)){
            context.result("running");
        }else{
            context.result("not running");
        }
    }
 

private void handleQueryConnectorConfig(Context context){

        String connectorName = context.param("connectorName");

        Map<String, ConnectKeyValue> connectorConfigs = connectController.getConfigManagementService().getConnectorConfigs();
        Map<String, List<ConnectKeyValue>> taskConfigs = connectController.getConfigManagementService().getTaskConfigs();
        StringBuilder sb = new StringBuilder();
        sb.append("ConnectorConfigs:")
            .append(JSON.toJSONString(connectorConfigs.get(connectorName)))
            .append("\n")
            .append("TaskConfigs:")
            .append(JSON.toJSONString(taskConfigs.get(connectorName)));
        context.result(sb.toString());
    }
 

private void handleResetStats(Context ctx) throws Exception {
    log.info("Reset stats");
    localWorker.resetStats();
}
 

private void handleCountersStats(Context ctx) throws Exception {
    ctx.result(writer.writeValueAsString(localWorker.getCountersStats()));
}
 

private static boolean isRefreshCheckDisabledInQuery(Context ctxt) {
  return Boolean.parseBoolean(ctxt.queryParam(RemoteHoodieTableFileSystemView.REFRESH_OFF));
}