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; }
/** * {@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)); } }
@Override public void put(final K key, final V value, final long windowStartTimestamp) { maybeUpdateSeqnumForDups(); bytesStore.put(WindowKeySchema.toStoreKeyBinary(key, windowStartTimestamp, seqnum, serdes), serdes.rawValue(value)); }
@Override public void put(final Windowed<K> sessionKey, final AGG aggregate) { bytesStore.put(Bytes.wrap(SessionKeySchema.toBinary(sessionKey, serdes.keySerializer(), topic)), serdes.rawValue(aggregate)); } }
@Override public void put(final K key, final V value, final long windowStartTimestamp) { final long startNs = time.nanoseconds(); try { inner.put(keyBytes(key), serdes.rawValue(value), windowStartTimestamp); } catch (final ProcessorStateException e) { final String message = String.format(e.getMessage(), key, value); throw new ProcessorStateException(message, e); } finally { metrics.recordLatency(this.putTime, startNs, time.nanoseconds()); } }
@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); } }
@Override public void put(final Windowed<K> sessionKey, final V aggregate) { Objects.requireNonNull(sessionKey, "sessionKey can't be null"); final long startNs = time.nanoseconds(); try { final Bytes key = keyBytes(sessionKey.key()); this.inner.put(new Windowed<>(key, sessionKey.window()), serdes.rawValue(aggregate)); } catch (final ProcessorStateException e) { final String message = String.format(e.getMessage(), sessionKey.key(), aggregate); throw new ProcessorStateException(message, e); } finally { this.metrics.recordLatency(this.putTime, startNs, time.nanoseconds()); } }
/** * {@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)); }
/** * {@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()); } }
this.bytesStore.put(Bytes.wrap(serdes.rawKey(currEventKey)), serdes.rawValue(sharedCurrEvent));
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); }