@Override public boolean hasWindowFor(long timestamp) { return getWindowFor(timestamp) != null; }
public StreamSortedWindowOnHeap(long start, long end, long margin) { this(start, end, margin, new PartitionedEventTimeOrderingComparator()); }
public void prepare(StreamContext context, PartitionedEventCollector outputCollector) { this.streamTimeClockManager = new StreamTimeClockManagerImpl(); this.streamSortHandlers = new HashMap<>(); this.outputCollector = outputCollector; this.context = context; }
public StreamWindow createWindow(long start, long end, long margin, StorageType type) { StreamWindow ret; switch (type) { case ONHEAP: ret = new StreamSortedWindowOnHeap(start, end, margin); break; default: ret = new StreamSortedWindowInMapDB( start, end, margin, createMapDB(type), UUID.randomUUID().toString() ); break; } if (LOG.isDebugEnabled()) { LOG.debug("Created new {}, type: {}", ret, type); } return ret; }
private void closeAndRemoveWindow(StreamWindow windowBucket) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); closeWindow(windowBucket); removeWindow(windowBucket); stopWatch.stop(); LOG.info("Removed {} in {} ms", windowBucket, stopWatch.getTime()); }
@Override public Object valueArrayUpdateVal(Object vals, int pos, PartitionedEvent[] newValue) { return delegate.valueArrayUpdateVal(vals, pos, serialize(newValue)); }
@Override public PartitionedEvent[] valueArrayGet(Object vals, int pos) { return deserialize(delegate.valueArrayGet(vals, pos)); }
@Override public void close() { timer.cancel(); triggerTickOnAll(); LOG.info("Closed StreamTimeClockManager {}", this); } }
private void triggerTickOnAll() { synchronized (listenerStreamIdMap) { for (Map.Entry<StreamTimeClockListener, String> entry : listenerStreamIdMap.entrySet()) { triggerTickOn(entry.getValue()); } } }
@Override public StreamTimeClock getStreamTimeClock(String streamId) { synchronized (streamIdTimeClockMap) { if (!streamIdTimeClockMap.containsKey(streamId)) { LOG.warn("TimeClock for stream {} is not initialized before being called, create now", streamId); return createStreamTimeClock(streamId); } return streamIdTimeClockMap.get(streamId); } }
@Override public void serialize(DataOutput2 out, PartitionedEvent[] value) throws IOException { out.packInt(value.length); for (PartitionedEvent event : value) { writePartitionedEvent(out, event); } }
@Override public PartitionedEvent[] deserialize(DataInput2 in, int available) throws IOException { final int size = in.unpackInt(); PartitionedEvent[] ret = new PartitionedEvent[size]; for (int i = 0; i < size; i++) { ret[i] = readPartitionedEvent(in); } return ret; }
@Override public void registerListener(StreamTimeClock streamClock, StreamTimeClockListener listener) { registerListener(streamClock.getStreamId(), listener); }
public void prepare(String streamId, StreamSortSpec streamSortSpecSpec, PartitionedEventCollector outputCollector) { this.windowManager = new StreamWindowManagerImpl( Period.parse(streamSortSpecSpec.getWindowPeriod()), streamSortSpecSpec.getWindowMargin(), PartitionedEventTimeOrderingComparator.INSTANCE, outputCollector); this.streamSortSpecSpec = streamSortSpecSpec; this.streamId = streamId; this.outputCollector = outputCollector; }
@Override protected void flush(PartitionedEventCollector collector) { synchronized (treeMultisetCache) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); treeMultisetCache.forEach(collector::emit); int size = treeMultisetCache.size(); treeMultisetCache.clear(); stopWatch.stop(); LOG.info("Flushed {} events in {} ms from {}", size, stopWatch.getTime(), this.toString()); } }
@SuppressWarnings("rawtypes") @Override public int valueArraySearch(Object keys, PartitionedEvent[] key, Comparator comparator) { return delegate.valueArraySearch(keys, serialize(key), comparator); }
@Override public PartitionedEvent[] deserialize(@NotNull DataInput2 input, int available) throws IOException { return deserialize(delegate.deserialize(input, available)); }
@Override public int valueArraySearch(Object keys, PartitionedEvent[] key) { return delegate.valueArraySearch(keys, serialize(key)); }
@Override public Object valueArrayPut(Object vals, int pos, PartitionedEvent[] newValue) { return delegate.valueArrayPut(vals, pos, serialize(newValue)); }
@Override public void serialize(@NotNull DataOutput2 out, @NotNull PartitionedEvent[] value) throws IOException { delegate.serialize(out, serialize(value)); }