@Override protected Object convertPayload(Message<?> message) { try { return Bytes.wrap(getObjectMapper().writeValueAsBytes(message.getPayload())); } catch (JsonProcessingException e) { throw new ConversionException("Failed to convert to JSON", e); } }
synchronized void putAll(final List<KeyValue<byte[], LRUCacheEntry>> entries) { for (final KeyValue<byte[], LRUCacheEntry> entry : entries) { put(Bytes.wrap(entry.key), entry.value); } }
@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 int compare(final Bytes cacheKey, final Windowed<Bytes> storeKey) { final Bytes storeKeyBytes = Bytes.wrap(SessionKeySchema.toBinary(storeKey)); return cacheFunction.compareSegmentedKeys(cacheKey, storeKeyBytes); } }
@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(); }
@Override public void put(final Windowed<Bytes> sessionKey, final byte[] aggregate) { bytesStore.put(sessionKey, aggregate); changeLogger.logChange(Bytes.wrap(SessionKeySchema.toBinary(sessionKey)), aggregate); }
/** * {@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 remove(final Windowed<Bytes> sessionKey) { bytesStore.remove(sessionKey); changeLogger.logChange(Bytes.wrap(SessionKeySchema.toBinary(sessionKey)), null); }
public static Windowed<Bytes> fromStoreKey(final byte[] binaryKey, final long windowSize) { final Bytes key = Bytes.wrap(extractStoreKeyBytes(binaryKey)); final Window window = extractStoreWindow(binaryKey, windowSize); return new Windowed<>(key, window); }
/** * {@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); }
@Override public void remove(final Windowed<K> key) { bytesStore.remove(Bytes.wrap(SessionKeySchema.toBinary(key, serdes.keySerializer(), topic))); }
@Override public void put(final Windowed<K> sessionKey, final AGG aggregate) { bytesStore.put(Bytes.wrap(SessionKeySchema.toBinary(sessionKey, serdes.keySerializer(), topic)), serdes.rawValue(aggregate)); } }
public static Windowed<Bytes> from(final Bytes bytesKey) { final byte[] binaryKey = bytesKey.get(); final Window window = extractWindow(binaryKey); return new Windowed<>(Bytes.wrap(extractKeyBytes(binaryKey)), window); }
@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 Windowed<Bytes> deserializeCacheKey(final Bytes cacheKey) { final byte[] binaryKey = cacheFunction.key(cacheKey).get(); final byte[] keyBytes = SessionKeySchema.extractKeyBytes(binaryKey); final Window window = SessionKeySchema.extractWindow(binaryKey); return new Windowed<>(Bytes.wrap(keyBytes), window); }
@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 apply(final List<ThreadCache.DirtyEntry> entries) { for (final ThreadCache.DirtyEntry entry : entries) { final byte[] binaryWindowKey = cacheFunction.key(entry.key()).get(); final long timestamp = WindowKeySchema.extractStoreTimestamp(binaryWindowKey); final Windowed<K> windowedKey = WindowKeySchema.fromStoreKey(binaryWindowKey, windowSize, serdes); final Bytes key = Bytes.wrap(WindowKeySchema.extractStoreKeyBytes(binaryWindowKey)); maybeForward(entry, key, windowedKey, (InternalProcessorContext) context); underlying.put(key, entry.newValue(), timestamp); } } });
private void buffer(final K key, final Change<V> value) { final long bufferTime = bufferTimeDefinition.time(internalProcessorContext, key); final ProcessorRecordContext recordContext = internalProcessorContext.recordContext(); final Bytes serializedKey = Bytes.wrap(keySerde.serializer().serialize(null, key)); final byte[] serializedValue = valueSerde.serializer().serialize(null, value); buffer.put(bufferTime, serializedKey, new ContextualRecord(serializedValue, recordContext)); }