Beispiel #1
0
  @Test
  public void testKillTaskSerde() throws Exception {
    final KillTask task = new KillTask(null, "foo", new Interval("2010-01-01/P1D"), null);

    final String json = jsonMapper.writeValueAsString(task);

    Thread.sleep(100); // Just want to run the clock a bit to make sure the task id doesn't change
    final KillTask task2 = (KillTask) jsonMapper.readValue(json, Task.class);

    Assert.assertEquals("foo", task.getDataSource());
    Assert.assertEquals(new Interval("2010-01-01/P1D"), task.getInterval());

    Assert.assertEquals(task.getId(), task2.getId());
    Assert.assertEquals(task.getGroupId(), task2.getGroupId());
    Assert.assertEquals(task.getDataSource(), task2.getDataSource());
    Assert.assertEquals(task.getInterval(), task2.getInterval());

    final KillTask task3 =
        (KillTask)
            jsonMapper.readValue(
                jsonMapper.writeValueAsString(
                    new ClientKillQuery("foo", new Interval("2010-01-01/P1D"))),
                Task.class);

    Assert.assertEquals("foo", task3.getDataSource());
    Assert.assertEquals(new Interval("2010-01-01/P1D"), task3.getInterval());
  }
  private HadoopDruidIndexerConfig testRunUpdateSegmentListIfDatasourcePathSpecIsUsed(
      PathSpec datasourcePathSpec, Interval jobInterval) throws Exception {
    HadoopIngestionSpec spec =
        new HadoopIngestionSpec(
            new DataSchema(
                "foo",
                null,
                new AggregatorFactory[0],
                new UniformGranularitySpec(
                    Granularity.DAY, null, ImmutableList.of(new Interval("2010-01-01/P1D"))),
                jsonMapper),
            new HadoopIOConfig(jsonMapper.convertValue(datasourcePathSpec, Map.class), null, null),
            null);

    spec = jsonMapper.readValue(jsonMapper.writeValueAsString(spec), HadoopIngestionSpec.class);

    UsedSegmentLister segmentLister = EasyMock.createMock(UsedSegmentLister.class);
    EasyMock.expect(
            segmentLister.getUsedSegmentsForIntervals(
                testDatasource, Lists.newArrayList(jobInterval)))
        .andReturn(ImmutableList.of(SEGMENT));
    EasyMock.replay(segmentLister);

    spec =
        HadoopIngestionSpec.updateSegmentListIfDatasourcePathSpecIsUsed(
            spec, jsonMapper, segmentLister);
    return HadoopDruidIndexerConfig.fromString(jsonMapper.writeValueAsString(spec));
  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
      throws IOException, ServletException {

    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = (HttpServletResponse) response;
    try {
      Authentication authentication = authenticationService.getAuthentication(httpRequest);
      SecurityContextHolder.getContext().setAuthentication(authentication);
      filterChain.doFilter(httpRequest, httpResponse);

    } catch (SignatureException exception) {
      httpResponse.setCharacterEncoding("UTF-8");
      httpResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
      httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

      ObjectMapper mapper = new ObjectMapper();

      FailureResponse error =
          new FailureResponse(
              httpRequest.getMethod(),
              httpRequest.getRequestURI(),
              "unauthorized JWT (invalid signature or expired token). Please use auth api to take another valid token.");
      httpResponse.getWriter().println(mapper.writeValueAsString(error));

      SecurityContextHolder.clearContext();

    } catch (MalformedJwtException exception) {
      httpResponse.setCharacterEncoding("UTF-8");
      httpResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
      httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);

      ObjectMapper mapper = new ObjectMapper();

      FailureResponse error =
          new FailureResponse(
              httpRequest.getMethod(),
              httpRequest.getRequestURI(),
              "malformed token. Please use auth api to take another valid token.");
      httpResponse.getWriter().println(mapper.writeValueAsString(error));

      SecurityContextHolder.clearContext();

    } catch (Exception exception) {
      httpResponse.setCharacterEncoding("UTF-8");
      httpResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
      httpResponse.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

      ObjectMapper mapper = new ObjectMapper();

      FailureResponse error =
          new FailureResponse(
              httpRequest.getMethod(),
              httpRequest.getRequestURI(),
              "Internal server error, please contact the backend team.");
      httpResponse.getWriter().println(mapper.writeValueAsString(error));
      LOGGER.error(exception.getMessage(), exception);
      SecurityContextHolder.clearContext();
    }
  }
  @Around("execution(@com.marcolenzo.gameboard.annotations.ActionLoggable * *(..))")
  public Object around(ProceedingJoinPoint point) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = point.proceed();

    User currentUser = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();

    Action action = new Action();
    action.setName(MethodSignature.class.cast(point.getSignature()).getMethod().getName());

    // Parse args
    List<String> jsonStrings = Lists.newArrayList();
    for (Object obj : point.getArgs()) {

      jsonStrings.add(mapper.writeValueAsString(obj));
    }
    action.setArgs(jsonStrings);
    action.setResult(mapper.writeValueAsString(result));

    action.setUserId(currentUser.getId());
    action.setDatetime(LocalDateTime.now());

    repository.save(action);

    LOGGER.info(
        "#{}({}): in {} ms by {}",
        MethodSignature.class.cast(point.getSignature()).getMethod().getName(),
        point.getArgs(),
        System.currentTimeMillis() - start,
        currentUser.getId() + " " + currentUser.getEmail());

    return result;
  }
Beispiel #5
0
 protected ContentResponse putRule(HttpCriteria criteria, Collection<HttpEntry> responseEntries)
     throws JsonProcessingException, InterruptedException, TimeoutException, ExecutionException {
   return newRequest()
       .path(PUT_FULL_RULE_PATH)
       .method(HttpMethod.PUT)
       .param("criteria", MAPPER.writeValueAsString(criteria))
       .param("response", MAPPER.writeValueAsString(responseEntries))
       .send();
 }
Beispiel #6
0
  @Override
  public AsyncFuture<Void> run(final ShellIO io, final TaskParameters base) throws Exception {
    final Parameters params = (Parameters) base;

    final String queryString = params.query.stream().collect(Collectors.joining(" "));

    final ObjectMapper indent = mapper.copy();
    indent.configure(SerializationFeature.INDENT_OUTPUT, true);

    final QueryOptions.Builder optionsBuilder = QueryOptions.builder().tracing(params.tracing);

    params.dataLimit.ifPresent(optionsBuilder::dataLimit);
    params.groupLimit.ifPresent(optionsBuilder::groupLimit);
    params.seriesLimit.ifPresent(optionsBuilder::seriesLimit);

    final QueryOptions options = optionsBuilder.build();

    final Optional<QueryDateRange> range =
        Optional.of(new QueryDateRange.Relative(TimeUnit.DAYS, 1));

    return query
        .useGroup(params.group)
        .query(
            query
                .newQueryFromString(queryString)
                .options(Optional.of(options))
                .rangeIfAbsent(range)
                .build())
        .directTransform(
            result -> {
              for (final RequestError e : result.getErrors()) {
                io.out().println(String.format("ERR: %s", e.toString()));
              }

              io.out().println(String.format("LIMITS: %s", result.getLimits().getLimits()));

              for (final ShardedResultGroup resultGroup : result.getGroups()) {
                final MetricCollection group = resultGroup.getMetrics();

                io.out()
                    .println(
                        String.format(
                            "%s: %s %s",
                            group.getType(),
                            resultGroup.getShard(),
                            indent.writeValueAsString(resultGroup.getSeries())));
                io.out().println(indent.writeValueAsString(group.getData()));
                io.out().flush();
              }

              io.out().println("TRACE:");
              result.getTrace().formatTrace(io.out());
              io.out().flush();

              return null;
            });
  }
  @Test
  public void testV1Serialization() throws Exception {

    final Interval interval = new Interval("2011-10-01/2011-10-02");
    final ImmutableMap<String, Object> loadSpec =
        ImmutableMap.<String, Object>of("something", "or_other");

    DataSegment segment =
        new DataSegment(
            "something",
            interval,
            "1",
            loadSpec,
            Arrays.asList("dim1", "dim2"),
            Arrays.asList("met1", "met2"),
            NoneShardSpec.instance(),
            IndexIO.CURRENT_VERSION_ID,
            1);

    final Map<String, Object> objectMap =
        mapper.readValue(
            mapper.writeValueAsString(segment), new TypeReference<Map<String, Object>>() {});

    Assert.assertEquals(10, objectMap.size());
    Assert.assertEquals("something", objectMap.get("dataSource"));
    Assert.assertEquals(interval.toString(), objectMap.get("interval"));
    Assert.assertEquals("1", objectMap.get("version"));
    Assert.assertEquals(loadSpec, objectMap.get("loadSpec"));
    Assert.assertEquals("dim1,dim2", objectMap.get("dimensions"));
    Assert.assertEquals("met1,met2", objectMap.get("metrics"));
    Assert.assertEquals(ImmutableMap.of("type", "none"), objectMap.get("shardSpec"));
    Assert.assertEquals(IndexIO.CURRENT_VERSION_ID, objectMap.get("binaryVersion"));
    Assert.assertEquals(1, objectMap.get("size"));

    DataSegment deserializedSegment =
        mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);

    Assert.assertEquals(segment.getDataSource(), deserializedSegment.getDataSource());
    Assert.assertEquals(segment.getInterval(), deserializedSegment.getInterval());
    Assert.assertEquals(segment.getVersion(), deserializedSegment.getVersion());
    Assert.assertEquals(segment.getLoadSpec(), deserializedSegment.getLoadSpec());
    Assert.assertEquals(segment.getDimensions(), deserializedSegment.getDimensions());
    Assert.assertEquals(segment.getMetrics(), deserializedSegment.getMetrics());
    Assert.assertEquals(segment.getShardSpec(), deserializedSegment.getShardSpec());
    Assert.assertEquals(segment.getSize(), deserializedSegment.getSize());
    Assert.assertEquals(segment.getIdentifier(), deserializedSegment.getIdentifier());

    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
    Assert.assertEquals(0, segment.compareTo(deserializedSegment));

    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
    Assert.assertEquals(0, deserializedSegment.compareTo(segment));

    deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
    Assert.assertEquals(segment.hashCode(), deserializedSegment.hashCode());
  }
  // [JACKSON-684]
  public void testAsIndex() throws Exception {
    // By default, serialize using name
    ObjectMapper m = new ObjectMapper();
    assertFalse(m.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX));
    assertEquals(quote("B"), m.writeValueAsString(TestEnum.B));

    // but we can change (dynamically, too!) it to be number-based
    m.enable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
    assertEquals("1", m.writeValueAsString(TestEnum.B));
  }
  @Test
  public void testVoteSuccess() {

    Vote correctVote = new Vote();
    correctVote.setRestaurantId(Long.MIN_VALUE);
    Restaurant restaurant = new Restaurant();
    restaurant.setRestaurantId(Long.MIN_VALUE);

    when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

    when(votingRepository.findByUser("admin")).thenReturn(null);

    try {
      MvcResult successVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(correctVote)))
              .andExpect(status().isOk())
              .andReturn();

      String outdatedVoteResString = successVoteRes.getResponse().getContentAsString();
      assertTrue(outdatedVoteResString.contains(Status.SUCCESS.getStatusValue()));
    } catch (Exception e) {
      fail();
    }

    LocalTime currentTime = LocalTime.now();
    if (currentTime.isBefore(RestaurantController.DEADLINE)) {
      Restaurant votingRestaurant = new Restaurant();
      votingRestaurant.setRestaurantId(Long.MAX_VALUE);
      Voting identicalVoting = new Voting();
      identicalVoting.setRestaurant(votingRestaurant);
      when(votingRepository.findByUser("admin")).thenReturn(identicalVoting);

      try {
        MvcResult actualVoteRes =
            mockMvc
                .perform(
                    post("/vote")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(mapper.writeValueAsString(correctVote)))
                .andExpect(status().isOk())
                .andReturn();

        String outdatedVoteResString = actualVoteRes.getResponse().getContentAsString();
        assertTrue(outdatedVoteResString.contains(Status.SUCCESS.getStatusValue()));
      } catch (Exception e) {
        fail();
      }
    }
  }
Beispiel #10
0
  @Test
  public void updateTask() throws Exception {
    // update existing task
    Task t = new Task();
    Long id = PermanentUserData.tasks.get(0).getId();
    t.setName("updated");
    t.setRole(new Role(PermanentUserData.tasks.get(0).getRole().getId()));
    given()
        .contentType("application/json")
        .filter(sessionFilter)
        .body(om.writeValueAsString(t))
        .put("/web/" + id.toString())
        .then()
        .statusCode(204);

    // delete it
    given()
        .header(PermanentUserData.tokenHeader)
        .delete("/m/" + PermanentUserData.tasks.get(0).getId())
        .then()
        .statusCode(204);

    // test if is recreated with correct values
    t.setNote("note");
    LocalTime moment = LocalTime.now();
    int minutes = moment.getMinute();
    int hours = moment.getHour();
    t.setTime(moment);
    given()
        .contentType("application/json")
        .header(PermanentUserData.tokenHeader)
        .body(om.writeValueAsString(t))
        .put("/m/" + id.toString())
        .then()
        .statusCode(204);
    try (Connection conn = ds.getConnection();
        PreparedStatement ps = conn.prepareStatement("select * from task where name = ?"); ) {
      ps.setString(1, "updated");
      try (ResultSet rs = ps.executeQuery(); ) {
        rs.next();
        assertThat(rs.getString("name"), equalTo("updated"));
        assertThat(rs.getString("note"), equalTo("note"));
        assertThat(rs.getTime("time").getMinutes(), equalTo(minutes));
        assertThat(rs.getTime("time").getHours(), equalTo(hours));
        // rest was set to default
        assertThat(rs.getBoolean("finished"), equalTo(false));
        assertThat(rs.getBoolean("important"), equalTo(false));
        assertThat(rs.getBoolean("finished"), equalTo(false));
        assertThat(rs.getDate("date"), equalTo(null));
        assertThat(rs.getDate("firstDate"), equalTo(null));
      }
    }
  }
Beispiel #11
0
  @Test
  public void serializesToXML() throws IOException {
    final Airlines airlines = new Airlines();
    airlines.getAirlines().add("All Nippon Airways");
    airlines.getAirlines().add("Cebu Pacific");

    final String expected =
        MAPPER.writeValueAsString(
            MAPPER.readValue(FixtureHelpers.fixture("fixtures/airlines.xml"), Airlines.class));

    Assert.assertEquals(MAPPER.writeValueAsString(airlines), expected);
  }
 private Map<String, String> details(Check check, List<Alert> alerts)
     throws JsonProcessingException {
   ObjectMapper mapper = new ObjectMapper();
   mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
   mapper.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false);
   mapper.setPropertyNamingStrategy(new PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy());
   return ImmutableMap.<String, String>builder()
       .put("CHECK", mapper.writeValueAsString(check))
       .put("STATE", check.getState().name())
       .put("ALERTS", mapper.writeValueAsString(alerts))
       .put("SEYREN_URL", seyrenConfig.getBaseUrl())
       .build();
 }
Beispiel #13
0
  public static void main(String[] args) throws Exception {
    keycloak = new KeycloakInstalled();
    br = new BufferedReader(new InputStreamReader(System.in));

    printHelp();
    printDivider();

    System.out.print("$ ");
    for (String s = br.readLine(); s != null; s = br.readLine()) {
      printDivider();

      try {
        if (s.equals("login")) {
          keycloak.login(System.out, br);
          System.out.println("Logged in: " + keycloak.getToken().getSubject());
        } else if (s.equals("logout")) {
          keycloak.logout();
          System.out.println("Logged out");
        } else if (s.equals("login-desktop")) {
          keycloak.loginDesktop();
          System.out.println("Logged in: " + keycloak.getToken().getSubject());
        } else if (s.equals("login-manual")) {
          keycloak.loginManual(System.out, br);
          System.out.println("Logged in: " + keycloak.getToken().getSubject());
        } else if (s.equals("profile")) {
          profile();
        } else if (s.equals("customers")) {
          customers();
        } else if (s.equals("token")) {
          System.out.println(mapper.writeValueAsString(keycloak.getToken()));
        } else if (s.equals("id-token")) {
          System.out.println(mapper.writeValueAsString(keycloak.getIdToken()));
        } else if (s.equals("refresh")) {
          keycloak.refreshToken();
          System.out.println(
              "Token refreshed: expires at " + Time.toDate(keycloak.getToken().getExpiration()));
        } else if (s.equals("exit")) {
          System.exit(0);
        } else {
          printHelp();
        }
      } catch (ServerRequest.HttpFailure t) {
        System.out.println(t.getError());
      } catch (Throwable t) {
        System.out.println(t.getMessage() != null ? t.getMessage() : t.getClass().toString());
      }
      printDivider();

      System.out.print("$ ");
    }
  }
  /**
   * Performs roundtrip test for the specified class.
   *
   * @param <TClass> Item class
   * @param item Item to be checked
   * @param asclass Class to be used during conversions
   * @return Deserialized object after the roundtrip
   * @throws IOException JSON Conversion error
   * @throws AssertionError Validation error
   */
  public static <TClass> TClass testRoundTrip(TClass item, Class<TClass> asclass)
      throws IOException, AssertionError {
    ObjectMapper mapper = new ObjectMapper();

    String serialized1 = mapper.writeValueAsString(item);
    JsonNode json1 = mapper.readTree(serialized1);
    TClass deserialized1 = mapper.readValue(serialized1, asclass);
    String serialized2 = mapper.writeValueAsString(deserialized1);
    JsonNode json2 = mapper.readTree(serialized2);
    TClass deserialized2 = mapper.readValue(serialized2, asclass);

    assertEquals(json2, json1, "JSONs must be equal after the second roundtrip");
    return deserialized2;
  }
  @Test
  public void should_serialize_to_JSON() throws Exception {
    // given
    final Restaurant representation = new Restaurant("MacDo");
    final String expected =
        MAPPER.writeValueAsString(
            MAPPER.readValue(fixture("fixtures/valid_restaurant.json"), Restaurant.class));

    // when
    String serializedRepresentation = MAPPER.writeValueAsString(representation);

    // then
    assertThat(serializedRepresentation).isEqualTo(expected);
  }
  @Test
  public void testVoteError() {
    try {
      Vote wrongVote = new Vote();
      wrongVote.setRestaurantId(Long.MAX_VALUE);
      when(restaurantRepository.findOne(Long.MAX_VALUE)).thenReturn(null);
      MvcResult wrongIdVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(wrongVote)))
              .andExpect(status().isOk())
              .andReturn();
      String wrongIdVoteResponseString = wrongIdVoteRes.getResponse().getContentAsString();
      assertTrue(wrongIdVoteResponseString.contains(Status.FAILED.getStatusValue()));
      assertTrue(wrongIdVoteResponseString.contains(RestaurantController.WRONG_RESTAURANT_MSG));

      LocalTime currentTime = LocalTime.now();
      if (currentTime.isAfter(RestaurantController.DEADLINE)) {

        Vote correctVote = new Vote();
        correctVote.setRestaurantId(Long.MIN_VALUE);
        Restaurant restaurant = new Restaurant();
        restaurant.setRestaurantId(Long.MIN_VALUE);

        when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

        Restaurant votingRestaurant = new Restaurant();
        votingRestaurant.setRestaurantId(Long.MAX_VALUE);
        Voting outdatedVoting = new Voting();
        outdatedVoting.setRestaurant(votingRestaurant);

        when(votingRepository.findByUser("admin")).thenReturn(outdatedVoting);

        MvcResult outdatedVoteRes =
            mockMvc
                .perform(
                    post("/vote")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(mapper.writeValueAsString(correctVote)))
                .andExpect(status().isOk())
                .andReturn();
        String outdatedVoteResString = outdatedVoteRes.getResponse().getContentAsString();
        assertTrue(outdatedVoteResString.contains(Status.FAILED.getStatusValue()));
      }
    } catch (Exception e) {
      fail();
    }
  }
 private void print(Collection<TopologyUsage> usages) {
   try {
     ObjectMapper om = new ObjectMapper();
     LOG.info(">>>" + om.writeValueAsString(usages));
   } catch (Exception e) {
   }
 }
Beispiel #18
0
 private static String toJSON(ObjectMapper mapper, Object object) {
   try {
     return mapper.writeValueAsString(object);
   } catch (JsonProcessingException e) {
     throw new IllegalArgumentException("Cannot marshal to JSON: " + object, e);
   }
 }
Beispiel #19
0
 /**
  * <br>
  * <b>功能:</b>输出JSON<br>
  * <b>作者:</b>肖财高<br>
  * <b>日期:</b> 2013-4-24 <br>
  *
  * @param response
  * @param type 0=成功 其他=失败
  * @param msg
  */
 public void toJsonMsg(HttpServletResponse response, int type, String msg) {
   Map<String, Object> map = new HashMap<String, Object>();
   ObjectMapper mapper = new ObjectMapper();
   map.put("state", type);
   if (type == 0) {
     map.put("success", true);
     if (msg == null) {
       map.put("msg", "成功");
     } else {
       map.put("msg", msg);
     }
   } else {
     map.put("success", false);
     if (msg == null) {
       map.put("msg", "失败");
     } else {
       map.put("msg", msg);
     }
   }
   try {
     this.toJsonPrint(response, mapper.writeValueAsString(map));
   } catch (JsonProcessingException e) {
     e.printStackTrace();
   }
 }
Beispiel #20
0
  /**
   * Creates CkanDataset on the server
   *
   * @param dataset data set with a given parameters
   * @return the newly created dataset
   * @throws JackanException
   */
  public synchronized CkanDataset createDataset(CkanDataset dataset) {

    logger.warning("TODO 0.4 CREATION OF FULL DATASETS IS EXPERIMENTAL!");

    checkNotNull(dataset);

    if (ckanToken == null) {
      throw new JackanException(
          "Tried to create dataset" + dataset.getName() + ", but ckan token was not set!");
    }

    ObjectMapper objectMapper = CkanClient.getObjectMapper();
    String json = null;
    try {
      json = objectMapper.writeValueAsString(dataset);
    } catch (IOException e) {
      throw new JackanException("Couldn't serialize the provided CkanDatasetMinimized!", this, e);
    }
    DatasetResponse datasetresponse =
        postHttp(
            DatasetResponse.class,
            "/api/3/action/package_create",
            json,
            ContentType.APPLICATION_JSON);
    return datasetresponse.result;
  }
  @Transactional
  @Rollback(true)
  @Test
  public void testUpdateWidgetInstance()
      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException,
          SecurityException, NoSuchMethodException, IOException {
    ObjectMapper objectMapper = new ObjectMapper();

    DefaultWidgetInstance defaultWidgetInstance = prepareData(objectMapper);

    Map<String, String> responsMap = uIService.createOrUpdateWidgetInstance(defaultWidgetInstance);
    Assert.isTrue(
        responsMap.get("widgetInstanceAction").equals("update"),
        "The response action should have been 'updated'");

    Canvas retrievedPerishableCanvas = uIService.getCanvasByName("Perishable Goods Canvas");
    List<DefaultWidgetInstance> retrievedDefaultWidgetInstances =
        retrievedPerishableCanvas.getWidgetInstanceList();

    DefaultWidgetInstance retrievedRefaultWidgetInstance = retrievedDefaultWidgetInstances.get(0);
    Assert.isTrue(
        objectMapper
            .writeValueAsString(actualViewConfig)
            .equals(retrievedRefaultWidgetInstance.getActualViewConfig()));
  }
  private void writeToPubsub(
      Time batchTime, int partitionId, Iterator<AggregateResult> aggregateResultIterator)
      throws IOException {
    String timestamp = ISODateTimeFormat.dateTime().print(batchTime.milliseconds());
    String batchId =
        getFormatterPrefix().print(batchTime.milliseconds())
            + batchTime.milliseconds()
            + "-"
            + partitionId;

    TreeMap<String, Object> batchMap = new TreeMap<>();
    batchMap.put("batch_id", batchId);

    List<Map<String, Object>> batches = new LinkedList<>();
    while (aggregateResultIterator.hasNext()) {
      AggregateResult aggrResult = aggregateResultIterator.next();
      TreeMap<String, Object> map = new TreeMap<>();
      map.putAll(aggrResult.getDimensions());
      map.putAll(aggrResult.getMetrics());
      map.put(WINDOW_TIMESTAMP_KEY, timestamp);
      batches.add(map);
    }

    if (batches.isEmpty()) return;
    batchMap.put("aggregated_result", batches);
    pubsubManager.writeAggregatedOutput(topic, objectMapper.writeValueAsString(batchMap));
  }
 protected <T, I> T handleCreate(I resource, Class<T> outputType)
     throws ExecutionException, InterruptedException, KubernetesClientException, IOException {
   RequestBody body = RequestBody.create(JSON, JSON_MAPPER.writeValueAsString(resource));
   Request.Builder requestBuilder =
       new Request.Builder().post(body).url(getNamespacedUrl(checkNamespace(resource)));
   return handleResponse(requestBuilder, 201, outputType);
 }
Beispiel #24
0
  @Test
  public void testMoveTaskSerde() throws Exception {
    final MoveTask task =
        new MoveTask(
            null,
            "foo",
            new Interval("2010-01-01/P1D"),
            ImmutableMap.<String, Object>of("bucket", "hey", "baseKey", "what"),
            null,
            null);

    final String json = jsonMapper.writeValueAsString(task);

    Thread.sleep(100); // Just want to run the clock a bit to make sure the task id doesn't change
    final MoveTask task2 = (MoveTask) jsonMapper.readValue(json, Task.class);

    Assert.assertEquals("foo", task.getDataSource());
    Assert.assertEquals(new Interval("2010-01-01/P1D"), task.getInterval());
    Assert.assertEquals(
        ImmutableMap.<String, Object>of("bucket", "hey", "baseKey", "what"),
        task.getTargetLoadSpec());

    Assert.assertEquals(task.getId(), task2.getId());
    Assert.assertEquals(task.getGroupId(), task2.getGroupId());
    Assert.assertEquals(task.getDataSource(), task2.getDataSource());
    Assert.assertEquals(task.getInterval(), task2.getInterval());
    Assert.assertEquals(task.getTargetLoadSpec(), task2.getTargetLoadSpec());
  }
Beispiel #25
0
 public static String escapeJsonString(String original) {
   try {
     return objectMapper.writeValueAsString(original);
   } catch (JsonProcessingException e) {
     return original;
   }
 }
Beispiel #26
0
  @Test
  public void testVersionConverterSubTaskSerde() throws Exception {
    final ConvertSegmentTask.SubTask task =
        new ConvertSegmentTask.SubTask(
            "myGroupId",
            DataSegment.builder()
                .dataSource("foo")
                .interval(new Interval("2010-01-01/P1D"))
                .version("1234")
                .build(),
            indexSpec,
            false,
            true,
            null);

    final String json = jsonMapper.writeValueAsString(task);

    Thread.sleep(100); // Just want to run the clock a bit to make sure the task id doesn't change
    final ConvertSegmentTask.SubTask task2 =
        (ConvertSegmentTask.SubTask) jsonMapper.readValue(json, Task.class);

    Assert.assertEquals("foo", task.getDataSource());
    Assert.assertEquals("myGroupId", task.getGroupId());

    Assert.assertEquals(task.getId(), task2.getId());
    Assert.assertEquals(task.getGroupId(), task2.getGroupId());
    Assert.assertEquals(task.getDataSource(), task2.getDataSource());
    Assert.assertEquals(task.getSegment(), task2.getSegment());
  }
  @Test
  public void testVoteNone() {

    Vote correctVote = new Vote();
    correctVote.setRestaurantId(Long.MIN_VALUE);
    Restaurant restaurant = new Restaurant();
    restaurant.setRestaurantId(Long.MIN_VALUE);

    when(restaurantRepository.findOne(Long.MIN_VALUE)).thenReturn(restaurant);

    Restaurant votingRestaurant = new Restaurant();
    votingRestaurant.setRestaurantId(Long.MIN_VALUE);
    Voting identicalVoting = new Voting();
    identicalVoting.setRestaurant(votingRestaurant);
    when(votingRepository.findByUser("admin")).thenReturn(identicalVoting);

    try {
      MvcResult outdatedVoteRes =
          mockMvc
              .perform(
                  post("/vote")
                      .contentType(MediaType.APPLICATION_JSON)
                      .content(mapper.writeValueAsString(correctVote)))
              .andExpect(status().isOk())
              .andReturn();

      String outdatedVoteResString = outdatedVoteRes.getResponse().getContentAsString();
      assertTrue(outdatedVoteResString.contains(Status.IGNORED.getStatusValue()));
    } catch (Exception e) {
      fail();
    }
  }
Beispiel #28
0
 @RequestMapping(value = "/contacts/email/{email}", method = GET)
 public String getContactByEmail(@PathVariable String email) throws JsonProcessingException {
   ObjectMapper mapper = new ObjectMapper();
   mapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
   ContactDto contact = contactService.getByEmail(email);
   return mapper.writeValueAsString(contact);
 }
Beispiel #29
0
  /** Add CRS (assumed to be EPSG:4326) to a GeoJSON string if it doesn't already exist */
  public static String addCrsToGeoJSON(String geoJson) throws BaleenException {
    if (Strings.isNullOrEmpty(geoJson)) {
      return geoJson;
    }

    try {
      Map<String, Object> geoJsonObj = MAPPER.readValue(geoJson, MAP_LIKE_TYPE);
      if (geoJsonObj.get("crs") == null) {
        Map<String, Object> crs = new HashMap<>();
        crs.put("type", "name");

        Map<String, Object> srid = new HashMap<>();
        srid.put("name", "EPSG:4326");
        crs.put("properties", srid);

        geoJsonObj.put("crs", crs);

        return MAPPER.writeValueAsString(geoJsonObj);
      } else {
        return geoJson;
      }
    } catch (Exception e) {
      throw new BaleenException("Unable to parse GeoJSON", e);
    }
  }
  /**
   * Sends a message envelope on this socket
   *
   * @param envelope The message envelope
   * @return This socket instance
   * @throws IOException Thrown if the message cannot be sent
   */
  public Socket push(final Envelope envelope) throws IOException {
    LOG.log(Level.FINE, "Pushing envelope: {0}", envelope);
    final ObjectNode node = objectMapper.createObjectNode();
    node.put("topic", envelope.getTopic());
    node.put("event", envelope.getEvent());
    node.put("ref", envelope.getRef());
    node.set(
        "payload",
        envelope.getPayload() == null ? objectMapper.createObjectNode() : envelope.getPayload());
    final String json = objectMapper.writeValueAsString(node);
    LOG.log(Level.FINE, "Sending JSON: {0}", json);

    RequestBody body = RequestBody.create(WebSocket.TEXT, json);

    if (this.isConnected()) {
      try {
        webSocket.sendMessage(body);
      } catch (IllegalStateException e) {
        LOG.log(Level.SEVERE, "Attempted to send push when socket is not open", e);
      }
    } else {
      this.sendBuffer.add(body);
    }

    return this;
  }