@Override public void emitWatermark(Watermark mark) { output.emitWatermark(mark); }
/** This will only be called if allowWatermark returned {@code true}. */ @Override protected void processAndEmitWatermark(Watermark mark) { nextWatermarkTime = Long.MAX_VALUE; output.emitWatermark(mark); // we can shutdown the watermark timer now, no watermarks will be needed any more. // Note that this procedure actually doesn't need to be synchronized with the lock, // but since it's only a one-time thing, doesn't hurt either final ScheduledFuture<?> nextWatermarkTimer = this.nextWatermarkTimer; if (nextWatermarkTimer != null) { nextWatermarkTimer.cancel(true); } }
public void processWatermark(Watermark mark) throws Exception { if (timeServiceManager != null) { timeServiceManager.advanceWatermark(mark); } output.emitWatermark(mark); }
@Override public void processWatermark(Watermark mark) throws Exception { output.emitWatermark(mark); } }
@Override public void processWatermark(Watermark mark) { output.emitWatermark(mark); } }
@Override public void processWatermark(Watermark mark) throws Exception { output.emitWatermark(mark); } }
@Override public void processWatermark(Watermark mark) throws Exception { output.emitWatermark(mark); } }
protected void handleWatermark(Watermark mark) { output.emitWatermark(mark); } }
@Override public void emitWatermark(Watermark mark) { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); for (Output<StreamRecord<OUT>> out : allOutputs) { out.emitWatermark(mark); } }
@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); } } }
@Override protected void handleWatermark(Watermark mark) { if (mark.equals(Watermark.MAX_WATERMARK)) { output.emitWatermark(mark); lastWatermark = Long.MAX_VALUE; } } }
@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); } } }
@Override public void emitWatermark(Watermark mark) { watermarkGauge.setCurrentWatermark(mark.getTimestamp()); if (streamStatusProvider.getStreamStatus().isActive()) { for (Output<StreamRecord<T>> output : outputs) { output.emitWatermark(mark); } } }
@Override protected void handleElement(StreamRecord<String> element) { long timestamp = Long.valueOf(element.getValue()); if (timestamp > lastWatermark) { output.emitWatermark(new Watermark(timestamp)); lastWatermark = timestamp; } }
@Override public void processWatermark(Watermark mark) throws Exception { output.emitWatermark(new Watermark(mark.getTimestamp() * 2)); } }
@Override public void onProcessingTime(long timestamp) throws Exception { // register next timer long newWatermark = userFunction.getCurrentWatermark(); if (newWatermark > currentWatermark) { currentWatermark = newWatermark; // emit watermark output.emitWatermark(new Watermark(currentWatermark)); } long now = getProcessingTimeService().getCurrentProcessingTime(); getProcessingTimeService().registerTimer(now + watermarkInterval, this); }
@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); }
@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 processElement(StreamRecord<T> element) throws Exception { long newTimestamp = userFunction.extractTimestamp(element.getValue(), element.getTimestamp()); output.collect(element.replace(element.getValue(), newTimestamp)); long watermark = userFunction.extractWatermark(element.getValue(), newTimestamp); if (watermark > currentWatermark) { currentWatermark = watermark; output.emitWatermark(new Watermark(currentWatermark)); } }
@Override public void processElement(StreamRecord<T> element) throws Exception { final T value = element.getValue(); final long newTimestamp = userFunction.extractTimestamp(value, element.hasTimestamp() ? element.getTimestamp() : Long.MIN_VALUE); output.collect(element.replace(element.getValue(), newTimestamp)); final Watermark nextWatermark = userFunction.checkAndGetNextWatermark(value, newTimestamp); if (nextWatermark != null && nextWatermark.getTimestamp() > currentWatermark) { currentWatermark = nextWatermark.getTimestamp(); output.emitWatermark(nextWatermark); } }