@Override
 protected void parseMember(JsonObject.Member member) {
   super.parseMember(member);
   try {
     JsonValue value = member.getValue();
     String memberName = member.getName();
     if ("roles".equals(memberName)) {
       this.writable =
           value
               .asArray()
               .values()
               .stream()
               .filter(JsonValue::isString)
               .map(JsonValue::asString)
               .anyMatch("write"::equalsIgnoreCase);
     } else if ("link".equals(memberName)) {
       link = new OneDriveSharingLink(value.asObject());
     } else if ("grantedTo".equals(memberName)) {
       grantedTo = new OneDriveIdentitySet(value.asObject());
     } else if ("inheritedFrom".equals(memberName)) {
       JsonObject valueObject = value.asObject();
       String id = valueObject.get("id").asString();
       OneDriveFolder inheritedFromFolder = new OneDriveFolder(getApi(), id);
       inheritedFrom = inheritedFromFolder.new Reference(valueObject);
     } else if ("shareId".equals(memberName)) {
       shareId = value.asString();
     }
   } catch (ParseException e) {
     throw new OneDriveRuntimeException("Parse failed, maybe a bug in client.", e);
   }
 }
Ejemplo n.º 2
0
  public static JsonValue removePaths(JsonValue jsonValue, Paths paths, Paths pathsToIgnore) {
    if (paths.matches(pathsToIgnore)) return JsonValue.NULL;

    if (jsonValue.isObject()) {
      paths = new Paths(paths);
      paths.extend("{}");

      if (paths.matches(pathsToIgnore)) return JsonValue.NULL;

      JsonObject jsonObject = new JsonObject();
      for (String name : jsonValue.asObject().names()) {
        Paths currentPaths = new Paths(paths);
        currentPaths.extend(name);
        jsonObject.set(
            name, removePaths(jsonValue.asObject().get(name), currentPaths, pathsToIgnore));
      }
      return jsonObject;
    }
    if (jsonValue.isArray()) {
      Paths currentPaths = new Paths(paths);
      currentPaths.extend("[]");

      if (currentPaths.matches(pathsToIgnore)) return JsonValue.NULL;

      JsonArray jsonArray = new JsonArray();
      for (int index = 0; index < jsonValue.asArray().size(); index++) {
        currentPaths = new Paths(paths);
        currentPaths.extend("[]", "[" + index + "]");

        jsonArray.add(removePaths(jsonValue.asArray().get(index), currentPaths, pathsToIgnore));
      }
      return jsonArray;
    }
    return jsonValue;
  }
Ejemplo n.º 3
0
 @Override
 public void getContactRequests(boolean fromWebsocket) throws ConnectionException {
   JsonArray array =
       Endpoints.AUTH_REQUESTS_URL
           .open(this)
           .as(JsonArray.class)
           .expect(200, "While loading authorization requests")
           .get();
   for (JsonValue contactRequest : array) {
     JsonObject contactRequestObj = contactRequest.asObject();
     try {
       ContactRequestImpl request =
           new ContactRequestImpl(
               contactRequestObj.get("event_time").asString(),
               getOrLoadContact(contactRequestObj.get("sender").asString()),
               contactRequestObj.get("greeting").asString(),
               this);
       if (!this.allContactRequests.contains(request)) {
         if (fromWebsocket) {
           ContactRequestEvent event = new ContactRequestEvent(request);
           getEventDispatcher().callEvent(event);
         }
         this.allContactRequests.add(request);
       }
     } catch (java.text.ParseException e) {
       getLogger().log(Level.WARNING, "Could not parse date for contact request", e);
     }
   }
   if (fromWebsocket) this.updateContactList();
 }
Ejemplo n.º 4
0
 @Override
 public GroupChat createGroupChat(Contact... contacts) throws ConnectionException {
   JsonObject obj = new JsonObject();
   JsonArray allContacts = new JsonArray();
   allContacts.add(new JsonObject().add("id", "8:" + this.getUsername()).add("role", "Admin"));
   for (Contact contact : contacts) {
     allContacts.add(new JsonObject().add("id", "8:" + contact.getUsername()).add("role", "User"));
   }
   obj.add("members", allContacts);
   HttpURLConnection con =
       Endpoints.THREAD_URL
           .open(this)
           .as(HttpURLConnection.class)
           .expect(201, "While creating group chat")
           .post(obj);
   String url = con.getHeaderField("Location");
   Matcher chatMatcher = URL_PATTERN.matcher(url);
   if (chatMatcher.find()) {
     String id = chatMatcher.group(1);
     while (this.getChat(id) == null) ;
     return (GroupChat) this.getChat(id);
   } else {
     throw ExceptionHandler.generateException("No chat location", con);
   }
 }
 @Override
 public JsonObject toJson() {
   final JsonObject root = new JsonObject();
   root.add("eventThreadCount", eventThreadCount);
   root.add("eventQueueCapacity", eventQueueCapacity);
   root.add("eventQueueSize", eventQueueSize);
   return root;
 }
Ejemplo n.º 6
0
 @Override
 public void fromJson(JsonObject json) {
   this.creationTime = json.getLong("creationTime", -1L);
   int status = json.getInt("status", WanSyncStatus.READY.getStatus());
   this.status = WanSyncStatus.getByStatus(status);
   this.syncedPartitionCount = json.getInt("syncedPartitionCount", 0);
   this.activeWanConfigName = json.getString("activeWanConfigName", null);
   this.activePublisherName = json.getString("activePublisherName", null);
 }
  @Test
  public void testPausingWanState() throws Exception {
    ChangeWanStateRequest changeWanStateRequest =
        new ChangeWanStateRequest("schema", "publisher", false);
    JsonObject jsonObject = new JsonObject();
    changeWanStateRequest.writeResponse(managementCenterService, jsonObject);

    JsonObject result = (JsonObject) jsonObject.get("result");
    assertNotEquals(ChangeWanStateRequest.SUCCESS, changeWanStateRequest.readResponse(result));
  }
 static void assertJSONContainsClassNameJustOnce(
     JsonObject jsonObject1, JsonObject jsonObject2, String className) {
   boolean firstClassFound =
       jsonObject1.get("stackTrace").toString().contains("$" + className + ".");
   boolean secondClassFound =
       jsonObject2.get("stackTrace").toString().contains("$" + className + ".");
   assertTrue(
       format(
           "JSON for Management Center should contain stackTrace with class name '%s' exactly once",
           className),
       firstClassFound ^ secondClassFound);
 }
  @Test
  public void extraComma() {
    JsonObject config = new JsonObject();
    if (versionGreaterThan("2.0.0")) {
      config.add("es3", true);
    }
    jsHint.configure(config);

    jsHint.check("var o = { x: 1, y: 2, z: 3, };", handler);

    assertThat(getAllProblems(), startsWith("1.26:Extra comma"));
  }
 @Override
 public JsonObject toJson() {
   JsonObject root = new JsonObject();
   root.add("name", config.getName());
   JsonArray publisherList = new JsonArray();
   for (WanPublisherConfig publisherConfig : config.getWanPublisherConfigs()) {
     WanPublisherConfigDTO dto = new WanPublisherConfigDTO(publisherConfig);
     publisherList.add(dto.toJson());
   }
   root.add("publishers", publisherList);
   return root;
 }
 @Override
 public void fromJson(JsonObject json) {
   config = new WanReplicationConfig();
   config.setName(json.get("name").asString());
   List<WanPublisherConfig> publisherConfigs = config.getWanPublisherConfigs();
   JsonArray publishers = json.get("publishers").asArray();
   int size = publishers.size();
   for (int i = 0; i < size; i++) {
     WanPublisherConfigDTO dto = new WanPublisherConfigDTO(new WanPublisherConfig());
     dto.fromJson(publishers.get(0).asObject());
     publisherConfigs.add(dto.getConfig());
   }
 }
Ejemplo n.º 12
0
 @Override
 public JsonObject toJson() {
   JsonObject root = new JsonObject();
   root.add("creationTime", creationTime);
   root.add("status", status.getStatus());
   root.add("syncedPartitionCount", syncedPartitionCount);
   if (activeWanConfigName != null) {
     root.add("activeWanConfigName", activeWanConfigName);
   }
   if (activePublisherName != null) {
     root.add("activePublisherName", activePublisherName);
   }
   return root;
 }
Ejemplo n.º 13
0
 private void doPublish(
     String name,
     Object val,
     String src,
     String dpt,
     String textual,
     long updateTime,
     long lastChange) {
   JsonObject jso = new JsonObject();
   jso.add("ts", updateTime).add("lc", lastChange).add("knx_src_addr", src).add("knx_dpt", dpt);
   if (textual != null) jso.add("knx_textual", textual);
   if (val instanceof Integer) jso.add("val", ((Integer) val).intValue());
   else if (val instanceof Number) jso.add("val", ((Number) val).doubleValue());
   else jso.add("val", val.toString());
   String txtmsg = jso.toString();
   MqttMessage msg = new MqttMessage(jso.toString().getBytes(StandardCharsets.UTF_8));
   msg.setQos(0);
   msg.setRetained(true);
   try {
     String fullTopic = topicPrefix + "status/" + name;
     mqttc.publish(fullTopic, msg);
     L.finer("Published " + txtmsg + " to " + fullTopic);
   } catch (MqttException e) {
     L.log(Level.WARNING, "Error when publishing message " + txtmsg, e);
   }
 }
  /** Tests the result of the rest api single subject single config GET when there is a config. */
  @Test
  public void testSingleSubjectSingleConfig() {
    setUpConfigData();
    final WebTarget wt = target();
    final String response =
        wt.path("network/configuration/devices/device1/basic").request().get(String.class);

    final JsonObject result = Json.parse(response).asObject();
    Assert.assertThat(result, notNullValue());

    Assert.assertThat(result.names(), hasSize(2));

    checkBasicAttributes(result);
  }
 static void assertJSONContainsClassName(JsonObject jsonObject, String className) {
   String stackTrace = jsonObject.get("stackTrace").toString();
   assertTrue(
       format(
           "JSON for Management Center should contain stackTrace with class name '%s'%n%s",
           className, stackTrace),
       stackTrace.contains("$" + className + "."));
 }
Ejemplo n.º 16
0
 @Override
 public void updateContactList() throws ConnectionException {
   JsonObject obj =
       Endpoints.GET_ALL_CONTACTS
           .open(this, getUsername(), "notification")
           .as(JsonObject.class)
           .expect(200, "While loading contacts")
           .get();
   for (JsonValue value : obj.get("contacts").asArray()) {
     if (value.asObject().get("suggested") == null
         || !value.asObject().get("suggested").asBoolean()) {
       String id = value.asObject().get("id").asString();
       ContactImpl impl = (ContactImpl) allContacts.get(id);
       impl.update(value.asObject());
     }
   }
 }
Ejemplo n.º 17
0
 @Override
 public String validate(FullSpec spec, JsonValue val) {
   if (!CHANGE.equals(spec.getOp())) {
     return VALID;
   }
   if (val.isObject()) {
     JsonObject jo = (JsonObject) val;
     for (String keySpecStr : jo.names()) {
       // member spec validity
       try {
         new TypeIdSpec(keySpecStr);
       } catch (IllegalArgumentException e) {
         return "invalid spec: " + keySpecStr;
       }
     }
   }
   return VALID;
 }
  @Test
  public void testShutdownCluster() throws Exception {
    ShutdownClusterRequest request = new ShutdownClusterRequest();

    cluster.getClusterState();
    JsonObject jsonObject = new JsonObject();
    request.writeResponse(managementCenterService, jsonObject);

    JsonObject result = (JsonObject) jsonObject.get("result");
    assertEquals("SUCCESS", request.readResponse(result));

    assertTrueEventually(
        new AssertTask() {
          @Override
          public void run() throws Exception {
            assertFalse(lifecycleService.isRunning());
          }
        });
  }
Ejemplo n.º 19
0
  @Override
  public void process(
      TernDoc doc,
      IJSONObjectHelper jsonObjectHelper,
      Object jsonObject,
      ITernLintCollector collector) {
    if (!(jsonObject instanceof JsonObject)) {
      // TODO: support for Rhino server
      return;
    }
    JsonArray messages = (JsonArray) ((JsonObject) jsonObject).get(MESSAGES_FIELD); // $NON-NLS-1$
    if (messages != null) {
      TernLintQuery query = (TernLintQuery) doc.getQuery();
      if (query.isGroupByFiles()) {
        JsonObject filesObject = null;
        String file = null;
        for (JsonValue files : messages) {
          filesObject = (JsonObject) files;
          file = jsonObjectHelper.getText(filesObject.get(FILE_FIELD)); // $NON-NLS-1$

          try {
            collector.startLint(file);

            JsonArray messagesFile = (JsonArray) filesObject.get(MESSAGES_FIELD); // $NON-NLS-1$
            if (messagesFile != null) {
              addMessages(jsonObjectHelper, messagesFile, query, collector);
            }
          } finally {
            collector.endLint(file);
          }
        }
      } else {
        String file = doc.getQuery().getFile();
        try {
          collector.startLint(file);
          addMessages(jsonObjectHelper, messages, query, collector);
        } finally {
          collector.endLint(file);
        }
      }
    }
  }
Ejemplo n.º 20
0
 @Override
 public ChatMessage sendMessage(Message message) throws ConnectionException {
   checkLoaded();
   try {
     long ms = System.currentTimeMillis();
     JsonObject obj = new JsonObject();
     obj.add("content", message.write());
     obj.add("messagetype", "RichText");
     obj.add("contenttype", "text");
     obj.add("clientmessageid", String.valueOf(ms));
     ConnectionBuilder builder = new ConnectionBuilder();
     builder.setUrl(getClient().withCloud(SEND_MESSAGE_URL, getIdentity()));
     builder.setMethod("POST", true);
     builder.addHeader("RegistrationToken", getClient().getRegistrationToken());
     builder.addHeader("Content-Type", "application/json");
     builder.setData(obj.toString());
     HttpURLConnection con = builder.build();
     if (con.getResponseCode() == 201) {
       return ChatMessageImpl.createMessage(
           this, getUser(getClient().getUsername()), null, String.valueOf(ms), ms, message);
     } else {
       throw getClient().generateException(con);
     }
   } catch (IOException e) {
     throw new ConnectionException("While sending a message", e);
   }
 }
Ejemplo n.º 21
0
  /** Tests GetAllMetrics method. */
  @Test
  public void testGetAllMetrics() {
    Counter onosCounter = new Counter();
    onosCounter.inc();

    Meter onosMeter = new Meter();
    onosMeter.mark();

    Timer onosTimer = new Timer();
    onosTimer.update(1, TimeUnit.MILLISECONDS);

    ImmutableMap<String, Metric> metrics =
        new ImmutableMap.Builder<String, Metric>()
            .put("onosCounter", onosCounter)
            .put("onosMeter", onosMeter)
            .put("onosTimer", onosTimer)
            .build();

    expect(mockMetricsService.getMetrics()).andReturn(metrics).anyTimes();

    replay(mockMetricsService);

    WebTarget wt = target();
    String response = wt.path("metrics").request().get(String.class);
    assertThat(response, containsString("{\"metrics\":["));

    JsonObject result = Json.parse(response).asObject();
    assertThat(result, notNullValue());

    JsonArray jsonMetrics = result.get("metrics").asArray();
    assertThat(jsonMetrics, notNullValue());
    assertThat(jsonMetrics.size(), is(3));

    assertTrue(
        matchesMetric(metrics.get("onosCounter")).matchesSafely(jsonMetrics.get(0).asObject()));
    assertTrue(
        matchesMetric(metrics.get("onosMeter")).matchesSafely(jsonMetrics.get(1).asObject()));
    assertTrue(
        matchesMetric(metrics.get("onosTimer")).matchesSafely(jsonMetrics.get(2).asObject()));
  }
  /** Tests the result of the rest api GET when there is a config. */
  @Test
  public void testConfigs() {
    setUpConfigData();
    final WebTarget wt = target();
    final String response = wt.path("network/configuration").request().get(String.class);

    final JsonObject result = Json.parse(response).asObject();
    Assert.assertThat(result, notNullValue());

    Assert.assertThat(result.names(), hasSize(2));

    JsonValue devices = result.get("devices");
    Assert.assertThat(devices, notNullValue());

    JsonValue device1 = devices.asObject().get("device1");
    Assert.assertThat(device1, notNullValue());

    JsonValue basic = device1.asObject().get("basic");
    Assert.assertThat(basic, notNullValue());

    checkBasicAttributes(basic);
  }
Ejemplo n.º 23
0
  @Override
  public void generateBuildScript(Configuration cfg, Context ctx) {
    try {
      final InputStream input =
          this.getClass().getClassLoader().getResourceAsStream("javascript/lib/package.json");
      final List<String> packLines = IOUtils.readLines(input);
      String pack = "";
      for (String line : packLines) {
        pack += line + "\n";
      }
      input.close();
      pack = pack.replace("<NAME>", cfg.getName());

      final JsonObject json = JsonObject.readFrom(pack);
      final JsonValue deps = json.get("dependencies");
      for (Thing t : cfg.allThings()) {
        for (String dep : t.annotation("js_dep")) {
          deps.asObject().add(dep.split(":")[0].trim(), dep.split(":")[1].trim());
        }
      }

      for (Thing t : cfg.allThings()) {
        if (t.getStreams().size() > 0) {
          deps.asObject().add("rx", "^2.5.3");
          deps.asObject().add("events", "^1.0.2");
          break;
        }
      }

      final File f = new File(ctx.getOutputDirectory() + "/" + cfg.getName() + "/package.json");
      f.setWritable(true);
      final PrintWriter w = new PrintWriter(new FileWriter(f));
      w.println(json.toString());
      w.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 24
0
  /** Tests the result of a rest api GET for flow classifier id. */
  @Test
  public void testGetFlowClassifierId() {

    final Set<FlowClassifier> flowClassifiers = new HashSet<>();
    flowClassifiers.add(flowClassifier1);

    expect(flowClassifierService.exists(anyObject())).andReturn(true).anyTimes();
    expect(flowClassifierService.getFlowClassifier(anyObject()))
        .andReturn(flowClassifier1)
        .anyTimes();
    replay(flowClassifierService);

    final WebResource rs = resource();
    final String response =
        rs.path("flow_classifiers/4a334cd4-fe9c-4fae-af4b-321c5e2eb051").get(String.class);
    final JsonObject result = JsonObject.readFrom(response);
    assertThat(result, notNullValue());
  }
Ejemplo n.º 25
0
 @Override
 public void loadAllContacts() throws ConnectionException {
   JsonObject object =
       Endpoints.GET_ALL_CONTACTS
           .open(this, getUsername(), "default")
           .as(JsonObject.class)
           .expect(200, "While loading contacts")
           .get();
   for (JsonValue value : object.get("contacts").asArray()) {
     JsonObject obj = value.asObject();
     if (obj.get("suggested") == null || !obj.get("suggested").asBoolean()) {
       if (!allContacts.containsKey(obj.get("id").asString())) {
         this.allContacts.put(obj.get("id").asString(), new ContactImpl(this, obj));
       }
     }
   }
 }
  @Override
  public OneDriveItem.Metadata next() throws OneDriveRuntimeException {
    JsonObject nextObject = jsonObjectIterator.next();
    String id = nextObject.get("id").asString();

    OneDriveItem.Metadata nextMetadata;
    if (nextObject.get("folder") != null && !nextObject.get("folder").isNull()) {
      OneDriveFolder folder = new OneDriveFolder(api, id);
      nextMetadata = folder.new Metadata(nextObject);
    } else if (nextObject.get("file") != null && !nextObject.get("file").isNull()) {
      OneDriveFile file = new OneDriveFile(api, id);
      nextMetadata = file.new Metadata(nextObject);
    } else {
      throw new OneDriveRuntimeException("The object type is currently not handled.");
    }
    return nextMetadata;
  }
Ejemplo n.º 27
0
  private String getEtag(URI uri) throws IOException {
    Response resp = adminExecutor.execute(Request.Get(uri));

    HttpResponse httpResp = resp.returnResponse();
    assertNotNull(httpResp);
    HttpEntity entity = httpResp.getEntity();
    assertNotNull(entity);
    StatusLine statusLine = httpResp.getStatusLine();
    assertNotNull(statusLine);

    assertEquals("check status code", HttpStatus.SC_OK, statusLine.getStatusCode());
    assertNotNull("content type not null", entity.getContentType());
    assertEquals(
        "check content type",
        Representation.HAL_JSON_MEDIA_TYPE,
        entity.getContentType().getValue());

    String content = EntityUtils.toString(entity);

    assertNotNull("", content);

    JsonObject json = null;

    try {
      json = JsonObject.readFrom(content);
    } catch (Throwable t) {
      fail("parsing received json");
    }

    assertNotNull("check not null json", json);

    assertNotNull("check not null _etag", json.get("_etag"));
    assertTrue("check _etag is object", json.get("_etag").isObject());

    assertNotNull("check not null _etag.$oid", json.get("_etag").asObject().get("$oid"));

    assertNotNull(
        "check _etag.$oid is string", json.get("_etag").asObject().get("$oid").isString());

    return json.get("_etag").asObject().get("$oid").asString();
  }
Ejemplo n.º 28
0
 protected void addMessages(
     IJSONObjectHelper helper,
     JsonArray messages,
     TernLintQuery query,
     ITernLintCollector collector) {
   String messageId = null;
   String message = null;
   String severity = null;
   String file = null;
   JsonObject messageObject = null;
   for (JsonValue value : messages) {
     messageObject = (JsonObject) value;
     messageId = helper.getText(messageObject.get(MESSAGE_ID_FIELD));
     message = query.formatMessage(helper.getText(messageObject.get(MESSAGE_FIELD)));
     severity = helper.getText(messageObject.get(MESSAGE_FIELD));
     severity = helper.getText(messageObject.get(SEVERITY_FIELD));
     Long startCh = helper.getCh(messageObject, FROM_FIELD);
     Long endCh = helper.getCh(messageObject, TO_FIELD);
     Long line = helper.getCh(messageObject, LINE_NUMBER_FIELD);
     file = helper.getText(messageObject.get(FILE_FIELD));
     collector.addMessage(
         messageId, message, startCh, endCh, line, severity, file, messageObject, helper);
   }
 }
Ejemplo n.º 29
0
    @Override
    public boolean matchesSafely(JsonObject jsonObject) {

      JsonObject jsonMetric = jsonObject.get("metric").asObject();
      JsonObject jsonCounter;
      JsonObject jsonMeter;
      JsonObject jsonTimer;
      Counter counter;
      Meter meter;
      Timer timer;

      // check counter metric
      if (jsonMetric.get("counter") != null) {
        jsonCounter = jsonMetric.get("counter").asObject();
        counter = (Counter) metric;
        if (jsonCounter.get("counter").asLong() != counter.getCount()) {
          reason = "counter " + counter.getCount();
          return false;
        }
      }

      // check meter metric
      if (jsonMetric.get("meter") != null) {
        jsonMeter = jsonMetric.get("meter").asObject();
        meter = (Meter) metric;

        if (jsonMeter.get("counter").asLong() != meter.getCount()) {
          reason = "counter " + meter.getCount();
          return false;
        }

        if (jsonMeter.get("1_min_rate").asDouble() != meter.getOneMinuteRate()) {
          reason = "1 minute rate " + meter.getOneMinuteRate();
          return false;
        }

        if (jsonMeter.get("5_min_rate").asDouble() != meter.getOneMinuteRate()) {
          reason = "5 minute rate " + meter.getFiveMinuteRate();
          return false;
        }

        if (jsonMeter.get("15_min_rate").asDouble() != meter.getFifteenMinuteRate()) {
          reason = "15 minute rate " + meter.getFifteenMinuteRate();
          return false;
        }
      }

      if (jsonMetric.get("timer") != null) {
        jsonTimer = jsonMetric.get("timer").asObject();
        timer = (Timer) metric;

        if (jsonTimer.get("counter").asLong() != timer.getCount()) {
          reason = "counter " + timer.getCount();
          return false;
        }

        if (jsonTimer.get("1_min_rate").asDouble() != timer.getOneMinuteRate()) {
          reason = "1 minute rate " + timer.getOneMinuteRate();
          return false;
        }

        if (jsonTimer.get("5_min_rate").asDouble() != timer.getOneMinuteRate()) {
          reason = "5 minute rate " + timer.getFiveMinuteRate();
          return false;
        }

        if (jsonTimer.get("15_min_rate").asDouble() != timer.getFifteenMinuteRate()) {
          reason = "15 minute rate " + timer.getFifteenMinuteRate();
          return false;
        }

        if (jsonTimer.get("mean").asDouble() != nanoToMs(timer.getSnapshot().getMean())) {
          reason = "mean " + timer.getSnapshot().getMean();
          return false;
        }

        if (jsonTimer.get("min").asDouble() != nanoToMs(timer.getSnapshot().getMin())) {
          reason = "min " + timer.getSnapshot().getMin();
          return false;
        }

        if (jsonTimer.get("max").asDouble() != nanoToMs(timer.getSnapshot().getMax())) {
          reason = "max " + timer.getSnapshot().getMax();
          return false;
        }

        if (jsonTimer.get("stddev").asDouble() != nanoToMs(timer.getSnapshot().getStdDev())) {
          reason = "stddev " + timer.getSnapshot().getStdDev();
          return false;
        }
      }

      return true;
    }
Ejemplo n.º 30
0
 public void remove(TypeIdSpec key_spec) throws SwarmException {
   JsonObject changes = new JsonObject();
   changes.set(key_spec.toString(), FALSE);
   change(changes);
 }