public void deleteTimer(Slice keyBytes, StateNamespace namespace, String timerId) { Set<Slice> timersForKey = activeTimers.get(keyBytes); if (timersForKey == null) { return; } Iterator<Slice> timerIt = timersForKey.iterator(); while (timerIt.hasNext()) { try { TimerData timerData = CoderUtils.decodeFromByteArray(timerDataCoder, timerIt.next().buffer); ComparisonChain chain = ComparisonChain.start().compare(timerData.getTimerId(), timerId); if (chain.result() == 0 && !timerData.getNamespace().equals(namespace)) { // Obtaining the stringKey may be expensive; only do so if required chain = chain.compare(timerData.getNamespace().stringKey(), namespace.stringKey()); } if (chain.result() == 0) { timerIt.remove(); } } catch (CoderException e) { throw new RuntimeException(e); } } if (timersForKey.isEmpty()) { activeTimers.remove(keyBytes); } }
/** @deprecated use {@link #deleteTimer(StateNamespace, String, TimeDomain)}. */ @Deprecated @Override public void deleteTimer(TimerData timer) { WindowTracing.trace("{}.deleteTimer: {}", getClass().getSimpleName(), timer); existingTimers.remove(timer.getNamespace(), timer.getTimerId()); timersForDomain(timer.getDomain()).remove(timer); }
private void fireTimer( TimerInternals.TimerData timer, BiConsumer<String, WindowedValue> timerConsumer) { StateNamespace namespace = timer.getNamespace(); Preconditions.checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); Instant timestamp = timer.getTimestamp(); WindowedValue<KV<Object, Timer>> timerValue = WindowedValue.of( KV.of(currentTimerKey, Timer.of(timestamp, new byte[0])), timestamp, Collections.singleton(window), PaneInfo.NO_FIRING); timerConsumer.accept(timer.getTimerId(), timerValue); }
timer.getNamespace() instanceof WindowNamespace, "Expected timer to be in WindowNamespace, but was in %s", timer.getNamespace()); @SuppressWarnings("unchecked") WindowNamespace<W> windowNamespace = (WindowNamespace<W>) timer.getNamespace(); W window = windowNamespace.getWindow();
(Coder<BoundedWindow>) inputWindowingStrategy.getWindowFn().windowCoder(), window); } else { stateNamespace = timer.getNamespace();
@Test public void testDeleteTimer() { TimerDataCoder timerDataCoder = TimerDataCoder.of(GlobalWindow.Coder.INSTANCE); String key1 = "key1"; Instant instant0 = new Instant(0); Instant instant1 = new Instant(1); ApexTimerInternals<String> timerInternals = new ApexTimerInternals<>(timerDataCoder); timerInternals.setContext(key1, StringUtf8Coder.of(), Instant.now(), null); TimerData timerData0 = TimerData.of("timerData0", StateNamespaces.global(), instant0, TimeDomain.EVENT_TIME); timerInternals.setTimer(timerData0); TimerData timerData1 = TimerData.of("timerData1", StateNamespaces.global(), instant1, TimeDomain.EVENT_TIME); timerInternals.setTimer(timerData1); Map<?, Set<Slice>> timerMap = timerInternals.getTimerSet(TimeDomain.EVENT_TIME).getMap(); assertEquals(1, timerMap.size()); assertEquals(2, timerMap.values().iterator().next().size()); timerInternals.deleteTimer(timerData0.getNamespace(), timerData0.getTimerId()); assertEquals(1, timerMap.size()); assertEquals(1, timerMap.values().iterator().next().size()); timerInternals.deleteTimer( timerData1.getNamespace(), timerData1.getTimerId(), TimeDomain.PROCESSING_TIME); assertEquals(1, timerMap.size()); assertEquals(1, timerMap.values().iterator().next().size()); timerInternals.deleteTimer( timerData1.getNamespace(), timerData1.getTimerId(), TimeDomain.EVENT_TIME); assertEquals(0, timerMap.size()); }
/** @deprecated use {@link #setTimer(StateNamespace, String, Instant, TimeDomain)}. */ @Deprecated @Override public void setTimer(TimerData timerData) { WindowTracing.trace("{}.setTimer: {}", getClass().getSimpleName(), timerData); @Nullable TimerData existing = existingTimers.get(timerData.getNamespace(), timerData.getTimerId()); if (existing == null) { existingTimers.put(timerData.getNamespace(), timerData.getTimerId(), timerData); timersForDomain(timerData.getDomain()).add(timerData); } else { checkArgument( timerData.getDomain().equals(existing.getDomain()), "Attempt to set %s for time domain %s, but it is already set for time domain %s", timerData.getTimerId(), timerData.getDomain(), existing.getDomain()); if (!timerData.getTimestamp().equals(existing.getTimestamp())) { NavigableSet<TimerData> timers = timersForDomain(timerData.getDomain()); timers.remove(existing); timers.add(timerData); existingTimers.put(timerData.getNamespace(), timerData.getTimerId(), timerData); } } }
/** * {@inheritDoc}. * * <p>Used for sorting {@link TimerData} by timestamp. Furthermore, we compare timers by all the * other fields so that {@code compareTo()} only returns 0 when {@code equals()} returns 0. This * ensures consistent sort order. */ @Override public int compareTo(TimerData that) { if (this.equals(that)) { return 0; } ComparisonChain chain = ComparisonChain.start() .compare(this.getTimestamp(), that.getTimestamp()) .compare(this.getDomain(), that.getDomain()) .compare(this.getTimerId(), that.getTimerId()); if (chain.result() == 0 && !this.getNamespace().equals(that.getNamespace())) { // Obtaining the stringKey may be expensive; only do so if required chain = chain.compare(getNamespace().stringKey(), that.getNamespace().stringKey()); } return chain.result(); } }
@Override public void fireTimer(Object key, Collection<TimerData> timerDataSet) { pushbackDoFnRunner.startBundle(); @SuppressWarnings("unchecked") Coder<Object> keyCoder = (Coder) currentKeyStateInternals.getKeyCoder(); ((StateInternalsProxy) currentKeyStateInternals).setKey(key); currentKeyTimerInternals.setContext( key, keyCoder, new Instant(this.currentInputWatermark), new Instant(this.currentOutputWatermark)); for (TimerData timerData : timerDataSet) { StateNamespace namespace = timerData.getNamespace(); checkArgument(namespace instanceof WindowNamespace); BoundedWindow window = ((WindowNamespace<?>) namespace).getWindow(); pushbackDoFnRunner.onTimer( timerData.getTimerId(), window, timerData.getTimestamp(), timerData.getDomain()); } pushbackDoFnRunner.finishBundle(); }
private void fireTimer( TimerInternals.TimerData timer, BiConsumer<String, WindowedValue> timerConsumer) { StateNamespace namespace = timer.getNamespace(); Preconditions.checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); Instant timestamp = timer.getTimestamp(); WindowedValue<KV<Object, Timer>> timerValue = WindowedValue.of( KV.of(currentTimerKey, Timer.of(timestamp, new byte[0])), timestamp, Collections.singleton(window), PaneInfo.NO_FIRING); timerConsumer.accept(timer.getTimerId(), timerValue); }
private static <T> BoundedWindow getUnderlyingWindow(KeyedWorkItem<byte[], T> kwi) { if (Iterables.isEmpty(kwi.elementsIterable())) { // ProcessFn sets only a single timer. TimerData timer = Iterables.getOnlyElement(kwi.timersIterable()); return ((WindowNamespace) timer.getNamespace()).getWindow(); } else { // KWI must have a single element in elementsIterable, because it follows a GBK by a // uniquely generated key. // Additionally, windows must be exploded before GBKIntoKeyedWorkItems, so there's also // only a single window. WindowedValue<T> value = Iterables.getOnlyElement(kwi.elementsIterable()); return Iterables.getOnlyElement(value.getWindows()); } }
private void fireTimer(TimerInternals.TimerData timer, DoFnRunner<KV<K, V>, OutputT> doFnRunner) { StateNamespace namespace = timer.getNamespace(); checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); doFnRunner.onTimer(timer.getTimerId(), window, timer.getTimestamp(), timer.getDomain()); }
private void fireTimer(TimerInternals.TimerData timer, DoFnRunner<KV<K, V>, OutputT> doFnRunner) { StateNamespace namespace = timer.getNamespace(); checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); doFnRunner.onTimer(timer.getTimerId(), window, timer.getTimestamp(), timer.getDomain()); }
private static void advanceInputWatermark( InMemoryTimerInternals timerInternals, Instant newInputWatermark, DoFnRunner<?, ?> toTrigger) throws Exception { timerInternals.advanceInputWatermark(newInputWatermark); TimerInternals.TimerData timer; while ((timer = timerInternals.removeNextEventTimer()) != null) { StateNamespace namespace = timer.getNamespace(); checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); toTrigger.onTimer(timer.getTimerId(), window, timer.getTimestamp(), timer.getDomain()); } }
public void fireTimer(InternalTimer<?, TimerData> timer) { TimerInternals.TimerData timerData = timer.getNamespace(); StateNamespace namespace = timerData.getNamespace(); // This is a user timer, so namespace must be WindowNamespace checkArgument(namespace instanceof WindowNamespace); BoundedWindow window = ((WindowNamespace) namespace).getWindow(); pushbackDoFnRunner.onTimer(timerData.getTimerId(), window, timerData.getTimestamp(), timerData.getDomain()); }
@Override public void encode(TimerData timer, OutputStream outStream) throws CoderException, IOException { STRING_CODER.encode(timer.getTimerId(), outStream); STRING_CODER.encode(timer.getNamespace().stringKey(), outStream); INSTANT_CODER.encode(timer.getTimestamp(), outStream); STRING_CODER.encode(timer.getDomain().name(), outStream); }
@Nullable private TimerData removeNextTimer(Instant currentTime, TimeDomain domain) { NavigableSet<TimerData> timers = timersForDomain(domain); if (!timers.isEmpty() && currentTime.isAfter(timers.first().getTimestamp())) { TimerData timer = timers.pollFirst(); existingTimers.remove(timer.getNamespace(), timer.getTimerId()); return timer; } else { return null; } } }
public void fireTimer(InternalTimer<?, TimerData> timer) { TimerInternals.TimerData timerData = timer.getNamespace(); StateNamespace namespace = timerData.getNamespace(); // This is a user timer, so namespace must be WindowNamespace checkArgument(namespace instanceof WindowNamespace); BoundedWindow window = ((WindowNamespace) namespace).getWindow(); timerInternals.cleanupPendingTimer(timer.getNamespace()); pushbackDoFnRunner.onTimer( timerData.getTimerId(), window, timerData.getTimestamp(), timerData.getDomain()); }
private void fireTimer( TimerInternals.TimerData timer, DoFnRunner<KV<K, V>, OutputT> doFnRunner) { StateNamespace namespace = timer.getNamespace(); checkArgument(namespace instanceof StateNamespaces.WindowNamespace); BoundedWindow window = ((StateNamespaces.WindowNamespace) namespace).getWindow(); doFnRunner.onTimer(timer.getTimerId(), window, timer.getTimestamp(), timer.getDomain()); }
public void fireTimer(InternalTimer<?, TimerData> timer) { TimerInternals.TimerData timerData = timer.getNamespace(); StateNamespace namespace = timerData.getNamespace(); // This is a user timer, so namespace must be WindowNamespace checkArgument(namespace instanceof WindowNamespace); BoundedWindow window = ((WindowNamespace) namespace).getWindow(); timerInternals.cleanupPendingTimer(timerData); pushbackDoFnRunner.onTimer( timerData.getTimerId(), window, timerData.getTimestamp(), timerData.getDomain()); }