Example usage for org.json.simple JSONObject size

List of usage examples for org.json.simple JSONObject size

Introduction

In this page you can find the example usage for org.json.simple JSONObject size.

Prototype

int size();

Source Link

Document

Returns the number of key-value mappings in this map.

Usage

From source file:edu.vt.vbi.patric.portlets.DiseaseOverview.java

@SuppressWarnings("unchecked")
public void serveResource(ResourceRequest request, ResourceResponse response)
        throws PortletException, IOException {

    response.setContentType("application/json");

    String type = request.getParameter("type");
    String cId = request.getParameter("cId");

    DBDisease conn_disease = new DBDisease();
    int count_total;
    JSONArray results = new JSONArray();
    PrintWriter writer = response.getWriter();

    if (type.equals("incidence")) {

        JSONObject jsonResult = new JSONObject();
        // String cType = request.getParameter("cType");

        // sorting
        // String sort_field = request.getParameter("sort");
        // String sort_dir = request.getParameter("dir");

        // Map<String, String> key = new HashMap<>();
        // Map<String, String> sort = null;
        ///*from ww w. j a  v  a 2  s .  c  o  m*/
        // if (sort_field != null && sort_dir != null) {
        // sort = new HashMap<String, String>();
        // sort.put("field", sort_field);
        // sort.put("direction", sort_dir);
        // }
        //
        // key.put("cId", cId);
        // key.put("cType", cType);
        count_total = 1;
        jsonResult.put("total", count_total);

        JSONObject obj = new JSONObject();
        obj.put("rownum", "1");
        obj.put("pathogen", "Pathogen");
        obj.put("disease", "Disease");
        obj.put("incidence", "10");
        obj.put("infection", "5");

        results.add(obj);
        jsonResult.put("results", results);

        jsonResult.writeJSONString(writer);
    } else if (type.equals("disease_tree")) {

        JSONArray jsonResult = new JSONArray();
        String tree_node = request.getParameter("node");
        List<ResultType> items = conn_disease.getMeshHierarchy(cId, tree_node);

        if (items.size() > 0) {
            int min = Integer.parseInt(items.get(0).get("lvl"));
            try {
                for (ResultType item : items) {
                    if (min == Integer.parseInt(item.get("lvl"))) {

                        boolean flag = false;
                        JSONObject obj = DiseaseOverview.encodeNodeJSONObject(item);

                        String mesh_id = (String) obj.get("tree_node");

                        for (int j = 0; j < jsonResult.size(); j++) {

                            JSONObject temp = (JSONObject) jsonResult.get(j);

                            if (temp.get("tree_node").equals(mesh_id)) {
                                flag = true;
                                temp.put("pathogen", temp.get("pathogen") + "<br>" + obj.get("pathogen"));
                                temp.put("genome", temp.get("genome") + "<br>" + obj.get("genome"));
                                temp.put("vfdb", temp.get("vfdb") + "<br>" + obj.get("vfdb"));
                                temp.put("gad", temp.get("gad") + "<br>" + obj.get("gad"));
                                temp.put("ctd", temp.get("ctd") + "<br>" + obj.get("ctd"));
                                temp.put("taxon_id", temp.get("taxon_id") + "<br>" + obj.get("taxon_id"));

                                jsonResult.set(j, temp);
                            }
                        }
                        if (!flag) {
                            jsonResult.add(obj);
                        }
                    }
                }
            } catch (Exception ex) {
                LOGGER.error(ex.getMessage(), ex);
            }
        }
        jsonResult.writeJSONString(writer);
    }
    writer.close();
}

From source file:i5.las2peer.services.mobsos.SurveyService.java

/**
 * TODO: write documentation/*  www.  j  a  v a  2 s.c o m*/
 * 
 * @param id
 * @param content
 * @return
 */
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Path("surveys/{id}/questionnaire")
@Summary("Set questionnaire for given survey.")
@ApiResponses(value = { @ApiResponse(code = 200, message = "Survey questionnaire set."),
        @ApiResponse(code = 400, message = "Invalid JSON for setting survey questionnaire."),
        @ApiResponse(code = 404, message = "Survey or questionnaire to be set does not exist.") })
public HttpResponse setSurveyQuestionnaire(@PathParam("id") int id, @ContentParam String content) {

    if (getActiveAgent().getId() == getActiveNode().getAnonymous().getId()) {
        HttpResponse noauth = new HttpResponse("Please authenticate to set questionnaire for survey!");
        noauth.setStatus(401);
    }

    String onAction = "setting questionnaire for survey " + id;

    try {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rset = null;

        try {

            int exown;
            exown = checkExistenceOwnership(id, 0);

            // check if survey exists; if not, return 404.
            if (exown == -1) {
                HttpResponse result = new HttpResponse("Survey " + id + " does not exist.");
                result.setStatus(404);
                return result;
            }
            // if survey exists, check if active agent is owner. if not, return 401.
            else if (exown == 0) {
                HttpResponse result = new HttpResponse("Survey " + id + " may only be managed by its owner.");
                result.setStatus(401);
                return result;
            }

            // if survey exists and active agent is owner, proceed.

            JSONObject o;

            // parse and validate content. If invalid, return 400 (bad request)
            try {
                o = (JSONObject) JSONValue.parseWithException(content);
            } catch (ParseException e) {
                HttpResponse result = new HttpResponse(e.getMessage());
                result.setStatus(400);
                return result;
            }

            if (!(o.size() == 1 && o.keySet().contains("qid"))) {
                HttpResponse result = new HttpResponse(
                        "Invalid JSON for setting questionnaire! Must only contain one field qid!");
                result.setStatus(400);
                return result;
            }

            // now check if questionnaire really exists
            int qid = Integer.parseInt(o.get("qid") + "");
            HttpResponse qresp = getQuestionnaire(qid);

            if (qresp.getStatus() != 200) {
                return qresp;
            }

            // if questionnaire exists, check if questionnaire form is defined already
            // if no form is defined, yet, return a not found.
            HttpResponse qformresp = downloadQuestionnaireForm(qid);
            if (qformresp.getStatus() == 404) {
                return qformresp;
            }

            // TODO: at this point we need to check, if users already submitted responses. What to do in this case to avoid data loss?
            // Responses should under no circumstances be deleted! Idea: respond with a forbidden error that asks user to first clear all 
            // responses before changing questionnaire. Requires DELETE support in resource surveys/{id}/responses.

            int responses = countResponses(id);

            if (responses > 0) {
                String msg = "Forbidden to change questionnaire, because end-user responses exist! "
                        + "To resolve this problem, first make sure to export existing survey response data. "
                        + "Then delete existing responses data with a DELETE to resource surveys/" + id
                        + "/responses." + "Then try again to change questionnaire.";

                HttpResponse forb = new HttpResponse(msg);
                forb.setStatus(403);
                return forb;
            }

            // if no responses are available, continue and change questionnaire
            conn = dataSource.getConnection();
            stmt = conn.prepareStatement("update " + jdbcSchema + ".survey set qid=? where id =?");

            stmt.setInt(1, qid);
            stmt.setInt(2, id);
            stmt.executeUpdate();

            HttpResponse result = new HttpResponse("Questionnaire for survey " + id + " set successfully.");
            result.setStatus(200);
            return result;

        } catch (SQLException | UnsupportedOperationException e) {
            return internalError(onAction);
        } finally {
            try {
                if (rset != null)
                    rset.close();
            } catch (Exception e) {
                e.printStackTrace();
                return internalError(onAction);
            }
            try {
                if (stmt != null)
                    stmt.close();
            } catch (Exception e) {
                e.printStackTrace();
                return internalError(onAction);
            }
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
                return internalError(onAction);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return internalError(onAction);
    }
}

From source file:fr.bmartel.bboxapi.BboxApi.java

@Override
public boolean getWirelessData(final IWirelessListener wirelessListener) {

    ClientSocket clientSocket = new ClientSocket("gestionbbox.lan", 80);

    clientSocket.addClientSocketEventListener(new IHttpClientListener() {

        @Override//w  ww.j av  a  2 s .com
        public void onIncomingHttpFrame(HttpFrame frame, HttpStates httpStates, IClientSocket clientSocket) {

            if (httpStates == HttpStates.HTTP_FRAME_OK && frame.isHttpResponseFrame()) {

                // this is data coming from the server
                if (frame.getStatusCode() == 200) {

                    String data = new String(frame.getBody().getBytes());

                    JSONArray obj = (JSONArray) JSONValue.parse(data);

                    if (obj.size() > 0) {

                        JSONObject item = (JSONObject) obj.get(0);
                        if (item.containsKey("wireless")) {

                            JSONObject sub_item_first_element = (JSONObject) item.get("wireless");

                            if (sub_item_first_element.containsKey("status")
                                    && sub_item_first_element.containsKey("radio")
                                    && sub_item_first_element.containsKey("ssid")
                                    && sub_item_first_element.containsKey("capabilities")
                                    && sub_item_first_element.containsKey("standard")) {

                                String status = sub_item_first_element.get("status").toString();

                                JSONObject radioItem = (JSONObject) sub_item_first_element.get("radio");

                                Iterator it = radioItem.entrySet().iterator();

                                HashMap<Integer, RadioObject> radioList = new HashMap<Integer, RadioObject>();
                                HashMap<Integer, SsidObject> ssidList = new HashMap<Integer, SsidObject>();

                                while (it.hasNext()) {

                                    Map.Entry<String, Object> pair = (Map.Entry) it.next();

                                    JSONObject subItem = (JSONObject) pair.getValue();

                                    boolean enable = false;
                                    String standard = "";
                                    int state = 0;
                                    int channel = 0;
                                    int currentChannel = 0;
                                    boolean dfs = false;
                                    boolean ht40 = false;

                                    if (subItem.containsKey("enable"))
                                        enable = Integer.parseInt(subItem.get("enable").toString()) == 1 ? true
                                                : false;
                                    if (subItem.containsKey("standard"))
                                        standard = subItem.get("standard").toString();
                                    if (subItem.containsKey("state"))
                                        state = Integer.parseInt(subItem.get("state").toString());
                                    if (subItem.containsKey("channel"))
                                        channel = Integer.parseInt(subItem.get("channel").toString());
                                    if (subItem.containsKey("current_channel"))
                                        currentChannel = Integer
                                                .parseInt(subItem.get("current_channel").toString());
                                    if (subItem.containsKey("dfs"))
                                        dfs = Integer.parseInt(subItem.get("dfs").toString()) == 1 ? true
                                                : false;
                                    if (subItem.containsKey("ht40")) {
                                        JSONObject ht40Object = (JSONObject) subItem.get("ht40");
                                        if (ht40Object.containsKey("enable"))
                                            ht40 = Integer.parseInt(subItem.get("enable").toString()) == 1
                                                    ? true
                                                    : false;
                                    }

                                    radioList.put(Integer.parseInt(pair.getKey()), new RadioObject(enable,
                                            standard, state, channel, currentChannel, dfs, ht40));
                                }

                                JSONObject ssidItem = (JSONObject) sub_item_first_element.get("ssid");

                                Iterator it2 = ssidItem.entrySet().iterator();

                                while (it2.hasNext()) {

                                    Map.Entry<String, Object> pair = (Map.Entry) it2.next();

                                    JSONObject subItem = (JSONObject) pair.getValue();

                                    String id = "";
                                    boolean enabled = false;
                                    boolean hidden = false;
                                    String bssid = "";
                                    boolean wmmenable = false;
                                    boolean wpsenabled = false;
                                    String wpsstatus = "";
                                    boolean securityDefault = false;
                                    String securityProtocol = "";
                                    String securityEncryption = "";
                                    String securityPassphrase = "";

                                    if (subItem.containsKey("id"))
                                        id = subItem.get("id").toString();
                                    if (subItem.containsKey("enable"))
                                        enabled = Integer.parseInt(subItem.get("enable").toString()) == 1 ? true
                                                : false;
                                    if (subItem.containsKey("hidden"))
                                        hidden = Integer.parseInt(subItem.get("hidden").toString()) == 1 ? true
                                                : false;
                                    if (subItem.containsKey("bssid"))
                                        bssid = subItem.get("bssid").toString();
                                    if (subItem.containsKey("wmmenable"))
                                        wmmenable = Integer.parseInt(subItem.get("wmmenable").toString()) == 1
                                                ? true
                                                : false;
                                    if (subItem.containsKey("wps")) {

                                        JSONObject wpsObject = (JSONObject) subItem.get("wps");

                                        if (wpsObject.containsKey("enable"))
                                            wpsenabled = Integer
                                                    .parseInt(wpsObject.get("enable").toString()) == 1 ? true
                                                            : false;
                                        if (wpsObject.containsKey("status"))
                                            wpsstatus = wpsObject.get("status").toString();
                                    }
                                    if (subItem.containsKey("security")) {

                                        JSONObject securityObject = (JSONObject) subItem.get("security");

                                        if (securityObject.containsKey("isdefault"))
                                            securityDefault = Integer
                                                    .parseInt(securityObject.get("isdefault").toString()) == 1
                                                            ? true
                                                            : false;
                                        if (securityObject.containsKey("protocol"))
                                            securityProtocol = securityObject.get("protocol").toString();
                                        if (securityObject.containsKey("encryption"))
                                            securityEncryption = securityObject.get("encryption").toString();
                                        if (securityObject.containsKey("passphrase"))
                                            securityPassphrase = securityObject.get("passphrase").toString();

                                    }

                                    ssidList.put(Integer.parseInt(pair.getKey()),
                                            new SsidObject(id, enabled, hidden, bssid, wmmenable, wpsenabled,
                                                    wpsstatus, securityDefault, securityProtocol,
                                                    securityEncryption, securityPassphrase));
                                }

                                JSONObject capabilityItems = (JSONObject) sub_item_first_element
                                        .get("capabilities");

                                Iterator it3 = capabilityItems.entrySet().iterator();

                                HashMap<Integer, List<WirelessCapability>> capabilityRadioList = new HashMap<Integer, List<WirelessCapability>>();

                                while (it3.hasNext()) {

                                    Map.Entry<String, Object> pair = (Map.Entry) it3.next();

                                    JSONArray subItem = (JSONArray) pair.getValue();

                                    List<WirelessCapability> wirelessCapabilityList = new ArrayList<WirelessCapability>();

                                    for (int i = 0; i < subItem.size(); i++) {

                                        JSONObject capabilityObj = (JSONObject) subItem.get(i);

                                        int channel = 0;
                                        String ht40 = "";
                                        boolean nodfs = false;
                                        int cactime = 0;
                                        int cactime40 = 0;

                                        if (capabilityObj.containsKey("channel"))
                                            channel = Integer.parseInt(capabilityObj.get("channel").toString());
                                        if (capabilityObj.containsKey("ht40"))
                                            ht40 = capabilityObj.get("ht40").toString();
                                        if (capabilityObj.containsKey("nodfs"))
                                            nodfs = Boolean.valueOf(capabilityObj.get("nodfs").toString());
                                        if (capabilityObj.containsKey("cactime"))
                                            cactime = Integer.parseInt(capabilityObj.get("cactime").toString());
                                        if (capabilityObj.containsKey("cactime40"))
                                            cactime40 = Integer
                                                    .parseInt(capabilityObj.get("cactime40").toString());

                                        wirelessCapabilityList.add(new WirelessCapability(channel, ht40, nodfs,
                                                cactime, cactime40));
                                    }

                                    capabilityRadioList.put(Integer.parseInt(pair.getKey()),
                                            wirelessCapabilityList);

                                }

                                JSONObject standardItems = (JSONObject) sub_item_first_element.get("standard");

                                Iterator it4 = standardItems.entrySet().iterator();

                                HashMap<Integer, List<String>> standardTypeList = new HashMap<Integer, List<String>>();

                                while (it4.hasNext()) {

                                    Map.Entry<String, Object> pair = (Map.Entry) it4.next();

                                    JSONArray subItem = (JSONArray) pair.getValue();

                                    List<String> typeList = new ArrayList<String>();

                                    for (int i = 0; i < subItem.size(); i++) {

                                        JSONObject typeOject = (JSONObject) subItem.get(i);

                                        if (typeOject.containsKey("value"))
                                            typeList.add(typeOject.get("value").toString());
                                    }

                                    standardTypeList.put(Integer.parseInt(pair.getKey()), typeList);
                                }

                                WirelessData wirelessData = new WirelessData(status, radioList, ssidList,
                                        capabilityRadioList, standardTypeList);

                                wirelessListener.onWirelessDataReceived(wirelessData);
                                clientSocket.closeSocket();
                                return;
                            }

                        }
                    }
                }
                wirelessListener.onWirelessDataFailure();
                clientSocket.closeSocket();
            }
        }

        @Override
        public void onSocketError() {

            wirelessListener.onWirelessDataFailure();
        }
    });

    HashMap<String, String> headers = new HashMap<String, String>();

    headers.put("Accept", "*/*");
    headers.put("Host", "gestionbbox.lan");
    headers.put("Cookie", token_header);
    HttpFrame frameRequest = new HttpFrame(HttpMethod.GET_REQUEST, new HttpVersion(1, 1), headers,
            "/api/v1/wireless", new ListOfBytes(""));

    clientSocket.write(frameRequest.toString().getBytes());

    return false;
}

From source file:nl.vumc.biomedbridges.galaxy.GalaxyWorkflow.java

/**
 * Parses the JSON / GA-file of a Galaxy workflow.
 *
 * // todo: use the GalaxyWorkflowMetadata class instead.
 *//*w  ww  .ja  v a 2  s .  co  m*/
public void parseJson() {
    try {
        inputsMetadata = new ArrayList<>();
        outputsMetadata = new ArrayList<>();
        final String jsonContent = getJsonContent();
        if (jsonContent != null) {
            final JSONObject workflowJson = (JSONObject) jsonParser.parse(jsonContent);
            final JSONObject stepsMapJson = (JSONObject) workflowJson.get("steps");
            logger.info("This workflow contains " + stepsMapJson.size() + " step"
                    + (stepsMapJson.size() != 1 ? "s" : "") + ":");

            // Sort the steps to have a well defined order.
            final SortedMap<Integer, JSONObject> sortedStepsMap = new TreeMap<>();
            for (final Object stepObject : stepsMapJson.entrySet())
                if (stepObject instanceof Map.Entry) {
                    final Map.Entry stepEntry = (Map.Entry) stepObject;
                    final int stepId = Integer.parseInt((String) stepEntry.getKey());
                    sortedStepsMap.put(stepId, (JSONObject) stepEntry.getValue());
                }

            for (final JSONObject stepJson : sortedStepsMap.values()) {
                addJsonInputs((JSONArray) stepJson.get("inputs"));
                addJsonOutputs((JSONArray) stepJson.get("outputs"));
            }
        }
    } catch (final ParseException e) {
        logger.error("Exception while parsing json design in workflow file {}.", getJsonFilename(), e);
    }
}

From source file:org.apache.ambari.view.capacityscheduler.ConfigurationService.java

/**
 * Checks if the user is an operator.//from   w w  w .  j  a  v  a2  s . c  o m
 *
 * @return    if <code>true</code>, the user is an operator; otherwise <code>false</code>
 */
private boolean isOperator() {
    validateViewConfiguration();

    // first check if the user is an CLUSTER.OPERATOR
    String url = String.format(CLUSTER_OPERATOR_PRIVILEGE_URL, context.getUsername());
    JSONObject json = readFromCluster(url);

    if (json == null || json.size() <= 0) {
        // user is not a CLUSTER.OPERATOR but might be an AMBARI.ADMIN
        url = String.format(AMBARI_ADMIN_PRIVILEGE_URL, context.getUsername());
        String response = ambariApi.readFromAmbari(url, "GET", null, null);
        if (response == null || response.isEmpty()) {
            return false;
        }
        json = getJsonObject(response);
        if (json == null || json.size() <= 0) {
            return false;
        }
    }

    return true;
}

From source file:org.apache.cassandra.tools.SSTableImport.java

/**
 * Convert a JSON formatted file to an SSTable.
 * /*from  www . ja  v a 2s  . c  om*/
 * @param jsonFile the file containing JSON formatted data
 * @param keyspace keyspace the data belongs to
 * @param cf column family the data belongs to
 * @param ssTablePath file to write the SSTable to
 * @throws IOException for errors reading/writing input/output
 * @throws ParseException for errors encountered parsing JSON input
 */
public static void importJson(String jsonFile, String keyspace, String cf, String ssTablePath)
        throws IOException, ParseException {
    ColumnFamily cfamily = ColumnFamily.create(keyspace, cf);
    String cfType = cfamily.type(); // Super or Standard
    IPartitioner<?> partitioner = DatabaseDescriptor.getPartitioner();
    DataOutputBuffer dob = new DataOutputBuffer();

    try {
        JSONObject json = (JSONObject) JSONValue.parseWithException(new FileReader(jsonFile));

        SSTableWriter writer = new SSTableWriter(ssTablePath, json.size(), partitioner);
        List<DecoratedKey<?>> decoratedKeys = new ArrayList<DecoratedKey<?>>();

        for (String key : (Set<String>) json.keySet())
            decoratedKeys.add(partitioner.decorateKey(key));
        Collections.sort(decoratedKeys);

        for (DecoratedKey<?> rowKey : decoratedKeys) {
            if (cfType.equals("Super"))
                addToSuperCF((JSONObject) json.get(rowKey.key), cfamily);
            else
                addToStandardCF((JSONArray) json.get(rowKey.key), cfamily);

            ColumnFamily.serializer().serializeWithIndexes(cfamily, dob);
            writer.append(rowKey, dob);
            dob.reset();
            cfamily.clear();
        }

        writer.closeAndOpenReader();
    } catch (ClassCastException cce) {
        throw new RuntimeException("Invalid JSON input, or incorrect column family.", cce);
    }
}

From source file:org.apache.hadoop.lib.service.instrumentation.TestInstrumentationService.java

@Test
public void timer() throws Exception {
    InstrumentationService.Timer timer = new InstrumentationService.Timer(2);
    InstrumentationService.Cron cron = new InstrumentationService.Cron();

    long ownStart;
    long ownEnd;//ww w .ja va2s  .com
    long totalStart;
    long totalEnd;
    long ownDelta;
    long totalDelta;
    long avgTotal;
    long avgOwn;

    cron.start();
    ownStart = Time.now();
    totalStart = ownStart;
    ownDelta = 0;
    sleep(100);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    sleep(100);

    cron.start();
    ownStart = Time.now();
    sleep(100);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    totalEnd = ownEnd;
    totalDelta = totalEnd - totalStart;

    avgTotal = totalDelta;
    avgOwn = ownDelta;

    timer.addCron(cron);
    long[] values = timer.getValues();
    assertEquals(values[InstrumentationService.Timer.LAST_TOTAL], totalDelta, 20);
    assertEquals(values[InstrumentationService.Timer.LAST_OWN], ownDelta, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_TOTAL], avgTotal, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_OWN], avgOwn, 20);

    cron = new InstrumentationService.Cron();

    cron.start();
    ownStart = Time.now();
    totalStart = ownStart;
    ownDelta = 0;
    sleep(200);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    sleep(200);

    cron.start();
    ownStart = Time.now();
    sleep(200);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    totalEnd = ownEnd;
    totalDelta = totalEnd - totalStart;

    avgTotal = (avgTotal * 1 + totalDelta) / 2;
    avgOwn = (avgOwn * 1 + ownDelta) / 2;

    timer.addCron(cron);
    values = timer.getValues();
    assertEquals(values[InstrumentationService.Timer.LAST_TOTAL], totalDelta, 20);
    assertEquals(values[InstrumentationService.Timer.LAST_OWN], ownDelta, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_TOTAL], avgTotal, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_OWN], avgOwn, 20);

    avgTotal = totalDelta;
    avgOwn = ownDelta;

    cron = new InstrumentationService.Cron();

    cron.start();
    ownStart = Time.now();
    totalStart = ownStart;
    ownDelta = 0;
    sleep(300);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    sleep(300);

    cron.start();
    ownStart = Time.now();
    sleep(300);

    cron.stop();
    ownEnd = Time.now();
    ownDelta += ownEnd - ownStart;
    totalEnd = ownEnd;
    totalDelta = totalEnd - totalStart;

    avgTotal = (avgTotal * 1 + totalDelta) / 2;
    avgOwn = (avgOwn * 1 + ownDelta) / 2;

    cron.stop();
    timer.addCron(cron);
    values = timer.getValues();
    assertEquals(values[InstrumentationService.Timer.LAST_TOTAL], totalDelta, 20);
    assertEquals(values[InstrumentationService.Timer.LAST_OWN], ownDelta, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_TOTAL], avgTotal, 20);
    assertEquals(values[InstrumentationService.Timer.AVG_OWN], avgOwn, 20);

    JSONObject json = (JSONObject) new JSONParser().parse(timer.toJSONString());
    assertEquals(json.size(), 4);
    assertEquals(json.get("lastTotal"), values[InstrumentationService.Timer.LAST_TOTAL]);
    assertEquals(json.get("lastOwn"), values[InstrumentationService.Timer.LAST_OWN]);
    assertEquals(json.get("avgTotal"), values[InstrumentationService.Timer.AVG_TOTAL]);
    assertEquals(json.get("avgOwn"), values[InstrumentationService.Timer.AVG_OWN]);

    StringWriter writer = new StringWriter();
    timer.writeJSONString(writer);
    writer.close();
    json = (JSONObject) new JSONParser().parse(writer.toString());
    assertEquals(json.size(), 4);
    assertEquals(json.get("lastTotal"), values[InstrumentationService.Timer.LAST_TOTAL]);
    assertEquals(json.get("lastOwn"), values[InstrumentationService.Timer.LAST_OWN]);
    assertEquals(json.get("avgTotal"), values[InstrumentationService.Timer.AVG_TOTAL]);
    assertEquals(json.get("avgOwn"), values[InstrumentationService.Timer.AVG_OWN]);
}

From source file:org.apache.hadoop.lib.service.instrumentation.TestInstrumentationService.java

@Test
public void sampler() throws Exception {
    final long value[] = new long[1];
    Instrumentation.Variable<Long> var = new Instrumentation.Variable<Long>() {
        @Override/*from ww  w.j a  v  a  2s . com*/
        public Long getValue() {
            return value[0];
        }
    };

    InstrumentationService.Sampler sampler = new InstrumentationService.Sampler();
    sampler.init(4, var);
    assertEquals(sampler.getRate(), 0f, 0.0001);
    sampler.sample();
    assertEquals(sampler.getRate(), 0f, 0.0001);
    value[0] = 1;
    sampler.sample();
    assertEquals(sampler.getRate(), (0d + 1) / 2, 0.0001);
    value[0] = 2;
    sampler.sample();
    assertEquals(sampler.getRate(), (0d + 1 + 2) / 3, 0.0001);
    value[0] = 3;
    sampler.sample();
    assertEquals(sampler.getRate(), (0d + 1 + 2 + 3) / 4, 0.0001);
    value[0] = 4;
    sampler.sample();
    assertEquals(sampler.getRate(), (4d + 1 + 2 + 3) / 4, 0.0001);

    JSONObject json = (JSONObject) new JSONParser().parse(sampler.toJSONString());
    assertEquals(json.size(), 2);
    assertEquals(json.get("sampler"), sampler.getRate());
    assertEquals(json.get("size"), 4L);

    StringWriter writer = new StringWriter();
    sampler.writeJSONString(writer);
    writer.close();
    json = (JSONObject) new JSONParser().parse(writer.toString());
    assertEquals(json.size(), 2);
    assertEquals(json.get("sampler"), sampler.getRate());
    assertEquals(json.get("size"), 4L);
}

From source file:org.apache.hadoop.lib.service.instrumentation.TestInstrumentationService.java

@Test
public void variableHolder() throws Exception {
    InstrumentationService.VariableHolder<String> variableHolder = new InstrumentationService.VariableHolder<String>();

    variableHolder.var = new Instrumentation.Variable<String>() {
        @Override/*from   ww  w .j  a  va2s  .co  m*/
        public String getValue() {
            return "foo";
        }
    };

    JSONObject json = (JSONObject) new JSONParser().parse(variableHolder.toJSONString());
    assertEquals(json.size(), 1);
    assertEquals(json.get("value"), "foo");

    StringWriter writer = new StringWriter();
    variableHolder.writeJSONString(writer);
    writer.close();
    json = (JSONObject) new JSONParser().parse(writer.toString());
    assertEquals(json.size(), 1);
    assertEquals(json.get("value"), "foo");
}

From source file:org.apache.metron.alerts.adapters.CIFAlertsAdapter.java

@SuppressWarnings("unchecked")
@Override//from   ww  w .  j  a v  a  2s.c  om
public Map<String, JSONObject> alert(JSONObject raw_message) {

    System.out.println("LOOKING FOR ENRICHMENT TAG: " + enrichment_tag);

    Map<String, JSONObject> alerts = new HashMap<String, JSONObject>();
    JSONObject content = (JSONObject) raw_message.get("message");

    JSONObject enrichment = null;

    if (raw_message.containsKey("enrichment"))
        enrichment = (JSONObject) raw_message.get("enrichment");
    else
        return null;

    if (enrichment.containsKey(enrichment_tag)) {

        System.out.println("FOUND TAG: " + enrichment_tag);

        JSONObject cif = (JSONObject) enrichment.get(enrichment_tag);

        int cnt = 0;
        Object enriched_key = null;

        for (Object key : cif.keySet()) {
            JSONObject tmp = (JSONObject) cif.get(key);
            cnt = cnt + tmp.size();
            if (tmp.size() > 0)
                enriched_key = key;
        }

        if (cnt == 0) {
            System.out.println("TAG HAS NO ELEMENTS");
            return null;
        }

        JSONObject alert = new JSONObject();

        String source = "unknown";
        String dest = "unknown";
        String host = "unknown";

        if (content.containsKey("ip_src_addr")) {
            source = content.get("ip_src_addr").toString();

            if (RangeChecker.checkRange(loaded_whitelist, source))
                host = source;
        }

        if (content.containsKey("ip_dst_addr")) {
            dest = content.get("ip_dst_addr").toString();

            if (RangeChecker.checkRange(loaded_whitelist, dest))
                host = dest;
        }

        JSONObject cifQualifier = (JSONObject) cif.get(enriched_key);

        alert.put("designated_host", host);
        String description = new StringBuilder().append(host).append(" communicated with a host (")
                .append(content.get(enriched_key).toString()).append(") identified as ")
                .append(cifQualifier.keySet().iterator().next().toString()).append(" by CIF").toString();
        alert.put("description", description);
        alert.put("priority", "MED");

        String alert_id = generateAlertId(source, dest, 0);

        alert.put("alert_id", alert_id);
        alerts.put(alert_id, alert);

        alert.put("enrichment", enrichment);

        return alerts;
    } else {
        System.out.println("DID NOT FIND TAG: " + enrichment_tag);
        return null;
    }

}