@Override public void processWatermark(Watermark mark) throws Exception { // if we receive a Long.MAX_VALUE watermark we forward it since it is used // to signal the end of input and to not block watermark progress downstream if (mark.getTimestamp() == Long.MAX_VALUE && mark.getTimestamp() > currentWatermark) { currentWatermark = Long.MAX_VALUE; output.emitWatermark(mark); } } }
@Nullable public Watermark checkAndGetNewWatermark(T record, long timestamp) { Watermark mark = timestampsAndWatermarks.checkAndGetNextWatermark(record, timestamp); if (mark != null && mark.getTimestamp() > partitionWatermark) { partitionWatermark = mark.getTimestamp(); return mark; } else { return null; } }
@Override public void processWatermark(Watermark mark) throws Exception { super.processWatermark(mark); this.currentWatermark = mark.getTimestamp(); }
public long getCurrentWatermarkTimestamp() { Watermark wm = timestampsAndWatermarks.getCurrentWatermark(); if (wm != null) { partitionWatermark = Math.max(partitionWatermark, wm.getTimestamp()); } return partitionWatermark; }
public void advanceWatermark(Watermark watermark) throws Exception { for (InternalTimerServiceImpl<?, ?> service : timerServices.values()) { service.advanceWatermark(watermark.getTimestamp()); } }
@Override public void processWatermark(Watermark mark) throws Exception { super.processWatermark(mark); this.currentWatermark = mark.getTimestamp(); }
@Override public void processWatermark(Watermark mark) throws Exception { super.processWatermark(mark); currentWatermark = mark.getTimestamp(); }
@Override public void processWatermark(Watermark mark) throws Exception { super.processWatermark(mark); currentWatermark = mark.getTimestamp(); }
@Override public void close() throws Exception { super.close(); // emit a final watermark Watermark newWatermark = userFunction.getCurrentWatermark(); if (newWatermark != null && newWatermark.getTimestamp() > currentWatermark) { currentWatermark = newWatermark.getTimestamp(); // emit watermark output.emitWatermark(newWatermark); } } }
public void processWatermark2(Watermark mark) throws Exception { input2Watermark = mark.getTimestamp(); long newMin = Math.min(input1Watermark, input2Watermark); if (newMin > combinedWatermark) { combinedWatermark = newMin; processWatermark(new Watermark(combinedWatermark)); } }
public void processWatermark1(Watermark mark) throws Exception { input1Watermark = mark.getTimestamp(); long newMin = Math.min(input1Watermark, input2Watermark); if (newMin > combinedWatermark) { combinedWatermark = newMin; processWatermark(new Watermark(combinedWatermark)); } }
@Override public void emitWatermark(Watermark mark) { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); for (Output<StreamRecord<OUT>> out : allOutputs) { out.emitWatermark(mark); } }
@Override public void emitWatermark(Watermark mark) { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); serializationDelegate.setInstance(mark); if (streamStatusProvider.getStreamStatus().isActive()) { try { recordWriter.broadcastEmit(serializationDelegate); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } }
@Override public void onProcessingTime(long timestamp) throws Exception { // register next timer Watermark newWatermark = userFunction.getCurrentWatermark(); if (newWatermark != null && newWatermark.getTimestamp() > currentWatermark) { currentWatermark = newWatermark.getTimestamp(); // emit watermark output.emitWatermark(newWatermark); } long now = getProcessingTimeService().getCurrentProcessingTime(); getProcessingTimeService().registerTimer(now + watermarkInterval, this); }
public OutputAsserter watermarkEquals(long timestamp) { Object record = output.poll(); if (record instanceof Watermark) { Watermark watermark = (Watermark) record; assertThat(watermark.getTimestamp(), is(timestamp)); } else { throw fail(record); } return this; } }
@Override public void emitWatermark(Watermark mark) { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); if (streamStatusProvider.getStreamStatus().isActive()) { for (Output<StreamRecord<T>> output : outputs) { output.emitWatermark(mark); } } }
@Override public void processWatermark(Watermark mark) throws Exception { super.processWatermark(mark); for (Watermark previousMark: watermarks) { assertTrue(previousMark.getTimestamp() < mark.getTimestamp()); } watermarks.add(mark); latch.trigger(); output.emitWatermark(mark); }
@Override public void emitWatermark(Watermark mark) { try { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); if (streamStatusProvider.getStreamStatus().isActive()) { operator.processWatermark(mark); } } catch (Exception e) { throw new ExceptionInChainedOperatorException(e); } }
@Override public void processWatermark(Watermark mark) throws Exception { output.emitWatermark(new Watermark(mark.getTimestamp() * 2)); } }
@Test public void testInitialAndFinalWatermark() { AscendingTimestampExtractor<Long> extractor = new LongExtractor(); assertEquals(Long.MIN_VALUE, extractor.getCurrentWatermark().getTimestamp()); extractor.extractTimestamp(Long.MIN_VALUE, -1L); extractor.extractTimestamp(Long.MAX_VALUE, -1L); assertEquals(Long.MAX_VALUE - 1, extractor.getCurrentWatermark().getTimestamp()); }