public static <K> Bytes toStoreKeyBinary(final K key, final long timestamp, final int seqnum, final StateSerdes<K, ?> serdes) { final byte[] serializedKey = serdes.rawKey(key); return toStoreKeyBinary(serializedKey, timestamp, seqnum); }
private Bytes keyBytes(final K key) { return Bytes.wrap(serdes.rawKey(key)); }
private Bytes keyBytes(final K key) { return Bytes.wrap(serdes.rawKey(key)); }
private List<KeyValue<Bytes, byte[]>> innerEntries(final List<KeyValue<K, V>> from) { final List<KeyValue<Bytes, byte[]>> byteEntries = new ArrayList<>(); for (final KeyValue<K, V> entry : from) { byteEntries.add(KeyValue.pair(Bytes.wrap(serdes.rawKey(entry.key)), serdes.rawValue(entry.value))); } return byteEntries; }
@Override public KeyValueIterator<Windowed<K>, AGG> findSessions(final K keyFrom, final K keyTo, final long earliestSessionEndTime, final long latestSessionStartTime) { final KeyValueIterator<Bytes, byte[]> bytesIterator = bytesStore.fetch( Bytes.wrap(serdes.rawKey(keyFrom)), Bytes.wrap(serdes.rawKey(keyTo)), earliestSessionEndTime, latestSessionStartTime ); return new WrappedSessionStoreIterator<>(bytesIterator, serdes); }
@Override public KeyValueIterator<Windowed<K>, V> fetch(final K from, final K to, final long timeFrom, final long timeTo) { final KeyValueIterator<Bytes, byte[]> bytesIterator = bytesStore.fetch(Bytes.wrap(serdes.rawKey(from)), Bytes.wrap(serdes.rawKey(to)), timeFrom, timeTo); return new WindowStoreIteratorWrapper<>(bytesIterator, serdes, windowSize).keyValueIterator(); }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") @Override public <T> T find(Aggregated<K> aggregated) { byte[] bytes = bytesStore.get(Bytes.wrap(serdes.rawKey(aggregated))); return (T) serdes.valueFrom(bytes); }
/** * {@inheritDoc} */ @Override public void put(final Runned key, final NFAStates state) { bytesStore.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(state)); }
@Override public <T> void put(Aggregated<K> aggregated, T aggregate) { bytesStore.put(Bytes.wrap(serdes.rawKey(aggregated)), serdes.rawValue(aggregate)); } }
/** * {@inheritDoc} */ @Override public NFAStates<K, V> find(final Runned key) { byte[] bytes = bytesStore.get(Bytes.wrap(serdes.rawKey(key))); return serdes.valueFrom(bytes); } }
public static <K> Bytes toStoreKeyBinary(final Windowed<K> timeKey, final int seqnum, final StateSerdes<K, ?> serdes) { final byte[] serializedKey = serdes.rawKey(timeKey.key()); return toStoreKeyBinary(serializedKey, timeKey.window().start(), seqnum); }
@Override public WindowStoreIterator<V> fetch(final K key, final long timeFrom, final long timeTo) { final KeyValueIterator<Bytes, byte[]> bytesIterator = bytesStore.fetch(Bytes.wrap(serdes.rawKey(key)), timeFrom, timeTo); return new WindowStoreIteratorWrapper<>(bytesIterator, serdes, windowSize).valuesIterator(); }
@Override public V get(final K key) { try { if (getTime.shouldRecord()) { return measureLatency(() -> outerValue(inner.get(Bytes.wrap(serdes.rawKey(key)))), getTime); } else { return outerValue(inner.get(Bytes.wrap(serdes.rawKey(key)))); } } catch (final ProcessorStateException e) { final String message = String.format(e.getMessage(), key); throw new ProcessorStateException(message, e); } }
@Override public V delete(final K key) { try { if (deleteTime.shouldRecord()) { return measureLatency(() -> outerValue(inner.delete(Bytes.wrap(serdes.rawKey(key)))), deleteTime); } else { return outerValue(inner.delete(Bytes.wrap(serdes.rawKey(key)))); } } catch (final ProcessorStateException e) { final String message = String.format(e.getMessage(), key); throw new ProcessorStateException(message, e); } }
@Override public V putIfAbsent(final K key, final V value) { if (putIfAbsentTime.shouldRecord()) { return measureLatency( () -> outerValue(inner.putIfAbsent(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(value))), putIfAbsentTime); } else { return outerValue(inner.putIfAbsent(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(value))); } }
@Override public void put(final K key, final V value) { try { if (putTime.shouldRecord()) { measureLatency(() -> { inner.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(value)); return null; }, putTime); } else { inner.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(value)); } } catch (final ProcessorStateException e) { final String message = String.format(e.getMessage(), key, value); throw new ProcessorStateException(message, e); } }
/** * {@inheritDoc} */ @Override public void branch(final Stage<K, V> stage, final Event<K, V> event, final DeweyVersion version) { Matched key = Matched.from(stage, event); MatchedEvent.Pointer pointer = new MatchedEvent.Pointer(version, key); while(pointer != null && (key = pointer.getKey()) != null) { byte[] bytes = this.bytesStore.get(Bytes.wrap(serdes.rawKey(key))); final MatchedEvent<K, V> val = serdes.valueFrom(bytes); val.incrementRefAndGet(); this.bytesStore.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(val)); pointer = val.getPointerByVersion(pointer.getVersion()); } }
private Sequence<K, V> peek(final Matched matched, DeweyVersion version, boolean remove) { MatchedEvent.Pointer pointer = new MatchedEvent.Pointer(version, matched); Sequence.Builder<K, V> builder = new Sequence.Builder<>(); while (pointer != null && pointer.getKey() != null) { final Matched key = pointer.getKey(); byte[] bytes = this.bytesStore.get(Bytes.wrap(serdes.rawKey(key))); final MatchedEvent<K, V> stateValue = serdes.valueFrom(bytes); long refsLeft = stateValue.decrementRefAndGet(); if (remove && refsLeft == 0 && stateValue.getPredecessors().size() <= 1) { this.bytesStore.delete(Bytes.wrap(serdes.rawKey(key))); } builder.add(key.getStageName(), newEvent(key, stateValue)); pointer = stateValue.getPointerByVersion(pointer.getVersion()); if (remove && pointer != null && refsLeft == 0) { stateValue.removePredecessor(pointer); this.bytesStore.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(stateValue)); } } return builder.build(true); }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") @Override public void put(final Stage<K, V> stage, final Event<K, V> event, final DeweyVersion version) { // A MatchedEvent can only by add once to a stack, so there is no need to check for existence. MatchedEvent<K, V> value = new MatchedEvent<>(event.key(), event.value(), event.timestamp()); value.addPredecessor(version, null); // register an empty predecessor to kept track of the version (akka run). final Matched matched = new Matched(stage.getName(), stage.getType(), event.topic(), event.partition(), event.offset()); LOG.debug("Putting event to store with key={}, value={}", matched, value); this.bytesStore.put(Bytes.wrap(serdes.rawKey(matched)), serdes.rawValue(value)); }