private T Store <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters, ITask streamTask) where T : class { var stateStore = streamTask.GetStore(storeQueryParameters.StoreName); if (stateStore != null && storeQueryParameters.QueryableStoreType.Accepts(stateStore)) { if (!stateStore.IsOpen) { throw new InvalidStateStoreException($"Cannot get state store {storeQueryParameters.StoreName} for task {streamTask} because the store is not open. The state store may have migrated to another instances."); } switch (stateStore) { case ITimestampedWindowStore <K, V> windowStore when storeQueryParameters.QueryableStoreType is WindowStoreType <K, V> : return(new ReadOnlyWindowStoreFacade <K, V>(windowStore) as T); case ITimestampedKeyValueStore <K, V> valueStore when storeQueryParameters.QueryableStoreType is KeyValueStoreType <K, V> : return(new ReadOnlyKeyValueStoreFacade <K, V>(valueStore) as T); case T store: return(store); } } return(null); }
public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { string storeName = storeQueryParameters.StoreName; IQueryableStoreType <T, K, V> queryableStoreType = storeQueryParameters.QueryableStoreType; IStateStore stateStore; if (!globalStateStores.TryGetValue(storeName, out stateStore) || !queryableStoreType.Accepts(stateStore)) { return(Enumerable.Empty <T>()); } if (!stateStore.IsOpen) { throw new InvalidStateStoreException($"the state store, {storeName}, is not open."); } if (stateStore is ITimestampedKeyValueStore <K, V> && queryableStoreType is KeyValueStoreType <K, V> ) { return(new[] { new ReadOnlyKeyValueStoreFacade <K, V>(stateStore as ITimestampedKeyValueStore <K, V>) as T }); } else if (stateStore is ITimestampedWindowStore <K, V> && queryableStoreType is WindowStoreType <K, V> ) { return(new[] { new ReadOnlyWindowStoreFacade <K, V>(stateStore as ITimestampedWindowStore <K, V>) as T }); } else { return new[] { stateStore as T } }; } }
public void GetElementInStateStore() { var timeout = TimeSpan.FromSeconds(10); var source = new CancellationTokenSource(); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.PollMs = 10; var supplier = new SyncKafkaSupplier(); var producer = supplier.GetProducer(config.ToProducerConfig()); var builder = new StreamBuilder(); builder.Table("topic", InMemory <string, string> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, supplier); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; stream.Start(source.Token); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var serdes = new StringSerDes(); producer.Produce("topic", new Confluent.Kafka.Message <byte[], byte[]> { Key = serdes.Serialize("key1"), Value = serdes.Serialize("coucou") }); Thread.Sleep(50); var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, string>())); Assert.IsNotNull(store); Assert.AreEqual(1, store.ApproximateNumEntries()); var item = store.Get("key1"); Assert.IsNotNull(item); Assert.AreEqual("coucou", item); } source.Cancel(); stream.Close(); }
public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { string storeName = storeQueryParameters.StoreName; IQueryableStoreType <T, K, V> queryableStoreType = storeQueryParameters.QueryableStoreType; IStateStore stateStore; if (!globalStateStores.TryGetValue(storeName, out stateStore) || !queryableStoreType.Accepts(stateStore)) { return(Enumerable.Empty <T>()); } if (!stateStore.IsOpen) { throw new InvalidStateStoreException($"the state store, {storeName}, is not open."); } if (stateStore is TimestampedKeyValueStore <K, V> && queryableStoreType is KeyValueStoreType <K, V> ) { return(new[] { new ReadOnlyKeyValueStoreFacade <K, V>(stateStore as TimestampedKeyValueStore <K, V>) as T }); } // TODO: handle TimestampedWindowStore //} else if (store instanceof TimestampedWindowStore && queryableStoreType instanceof QueryableStoreTypes.WindowStoreType) { // return (List<T>) Collections.singletonList(new ReadOnlyWindowStoreFacade((TimestampedWindowStore<Object, Object>) store)); //} return(new[] { stateStore as T }); }
public async Task BuildGlobalStateStore() { var timeout = TimeSpan.FromSeconds(10); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; config.PollMs = 1; var builder = new StreamBuilder(); builder.GlobalTable <string, string>("test", InMemory <string, string> .As("store")); var supplier = new SyncKafkaSupplier(); var producer = supplier.GetProducer(new ProducerConfig()); var t = builder.Build(); var stream = new KafkaStream(t, config, supplier); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; await stream.StartAsync(); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var stringSerdes = new StringSerDes(); producer.Produce("test", new Message <byte[], byte[]> { Key = stringSerdes.Serialize("key", new SerializationContext()), Value = stringSerdes.Serialize("value", new SerializationContext()) }); Thread.Sleep(250); var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, string>())); Assert.IsNotNull(store); Assert.AreEqual(1, store.ApproximateNumEntries()); } stream.Dispose(); }
public void ShouldNotReturnKeyValueStoreAsTimestampedStore() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(stores); var result = provider.Stores(StoreQueryParameters.FromNameAndType("kv-store", QueryableStoreTypes.TimestampedKeyValueStore <object, object>())); Assert.AreEqual(0, result.Count()); }
public void ShouldReturnTimestampedKeyValueStore() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(stores); var result = provider.Stores(StoreQueryParameters.FromNameAndType("ts-kv-store", QueryableStoreTypes.TimestampedKeyValueStore <object, object>())); Assert.AreEqual(timestampedKVStore, result.Single()); }
public void ShouldReturnEmptyItemListIfStoreDoesntExist() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(new Dictionary <string, IStateStore>()); var result = provider.Stores(StoreQueryParameters.FromNameAndType("test", QueryableStoreTypes.KeyValueStore <object, object>())); Assert.AreEqual(0, result.Count()); }
public void ShouldReturnWindowStore() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(stores); var result = provider.Stores(StoreQueryParameters.FromNameAndType("ws-store", QueryableStoreTypes.WindowStore <object, object>())); Assert.AreEqual(wStore, result.Single()); }
public void ShouldReturnWindowStoreAsTimestampedWindowStore() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(stores); var result = provider.Stores(StoreQueryParameters.FromNameAndType("ts-w-store", QueryableStoreTypes.WindowStore <object, object>())); Assert.AreEqual(1, result.Count()); }
public void ShouldThrowExceptionIfStoreIsNotOpen() { var mockStore = CreateMockStore <IKeyValueStore <object, object> >(isOpen: false); GlobalStateStoreProvider provider = new GlobalStateStoreProvider(new Dictionary <string, IStateStore> { { "test", mockStore } }); Assert.Throws <InvalidStateStoreException>(() => provider.Stores(StoreQueryParameters.FromNameAndType("test", QueryableStoreTypes.KeyValueStore <object, object>()))); }
public void ShouldReturnTimestampedKeyValueStoreAsKeyValueStore() { GlobalStateStoreProvider provider = new GlobalStateStoreProvider(stores); var result = provider.Stores(StoreQueryParameters.FromNameAndType("ts-kv-store", QueryableStoreTypes.KeyValueStore <object, object>())); Assert.IsInstanceOf(typeof(ReadOnlyKeyValueStore <object, object>), result.Single()); Assert.IsNotInstanceOf(typeof(TimestampedKeyValueStore <object, object>), result.Single()); }
static void Main(string[] args) { CancellationTokenSource source = new CancellationTokenSource(); var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test-app"; config.BootstrapServers = "192.168.56.1:9092"; config.SaslMechanism = SaslMechanism.Plain; config.SaslUsername = "******"; config.SaslPassword = "******"; config.SecurityProtocol = SecurityProtocol.SaslPlaintext; config.AutoOffsetReset = AutoOffsetReset.Earliest; config.NumStreamThreads = 1; StreamBuilder builder = new StreamBuilder(); builder.Stream <string, string>("test") .FilterNot((k, v) => v.Contains("test")) .To("test-output"); builder.Table("test-ktable", InMemory <string, string> .As("test-store")); Topology t = builder.Build(); KafkaStream stream = new KafkaStream(t, config); bool taskGetStateStoreRunning = false; stream.StateChanged += (old, @new) => { if (@new == KafkaStream.State.RUNNING && !taskGetStateStoreRunning) { Task.Factory.StartNew(() => { taskGetStateStoreRunning = true; while (!source.Token.IsCancellationRequested) { var store = stream.Store(StoreQueryParameters.FromNameAndType("test-store", QueryableStoreTypes.KeyValueStore <string, string>())); var items = store.All().ToList(); Thread.Sleep(500); } }, source.Token); } }; Console.CancelKeyPress += (o, e) => { source.Cancel(); stream.Close(); }; stream.Start(source.Token); }
public async Task GetWindowStateStore() { var timeout = TimeSpan.FromSeconds(10); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; var builder = new StreamBuilder(); builder .Stream <string, string>("test") .GroupByKey() .WindowedBy(TumblingWindowOptions.Of(TimeSpan.FromMinutes(1))) .Count(InMemoryWindows <string, long> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, new SyncKafkaSupplier()); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; await stream.StartAsync(); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.WindowStore <string, long>())); Assert.IsNotNull(store); } stream.Dispose(); }
public async Task GetStateStoreDoesntExists() { var timeout = TimeSpan.FromSeconds(10); bool isRunningState = false; DateTime dt = DateTime.Now; var supplier = new SyncKafkaSupplier(); var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; var builder = new StreamBuilder(); builder.Table("topic", InMemory <string, string> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, supplier); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; await stream.StartAsync(); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { Assert.Throws <InvalidStateStoreException>(() => stream.Store(StoreQueryParameters.FromNameAndType("stodfdsfdsfre", QueryableStoreTypes.KeyValueStore <string, string>()))); } stream.Dispose(); }
public void GetStateStore() { var timeout = TimeSpan.FromSeconds(10); var source = new CancellationTokenSource(); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; var builder = new StreamBuilder(); builder.Table("topic", InMemory <string, string> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, new SyncKafkaSupplier()); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; stream.Start(source.Token); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, string>()));; Assert.IsNotNull(store); } source.Cancel(); stream.Close(); }
public void GetStateStoreBeforeRunningState() { var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; var builder = new StreamBuilder(); builder.Table("topic", InMemory <string, string> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, new SyncKafkaSupplier()); Assert.Throws <IllegalStateException>(() => stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, string>()))); stream.Dispose(); }
public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { // TODO: handle 'staleStoresEnabled' and 'partition' when they are added to StoreQueryParameters if (this.streamThread.State == ThreadState.DEAD) { return(Enumerable.Empty <T>()); } if (!(this.streamThread.State == ThreadState.RUNNING)) { throw new InvalidStateStoreException($"Cannot get state store {storeQueryParameters.StoreName} because " + $"the stream thread is {streamThread.State}, not RUNNING"); } List <T> stores = new List <T>(); foreach (var streamTask in streamThread.ActiveTasks) { IStateStore store = streamTask.GetStore(storeQueryParameters.StoreName); if (store != null && storeQueryParameters.QueryableStoreType.Accepts(store)) { if (!store.IsOpen) { throw new InvalidStateStoreException($"Cannot get state store {storeQueryParameters.StoreName} for task {streamTask} because the " + $"store is not open. The state store may have migrated to another instances."); } // TODO: handle TimestampedWindowStore // else if (store instanceof TimestampedWindowStore && queryableStoreType instanceof QueryableStoreTypes.WindowStoreType) { // return (T)new ReadOnlyWindowStoreFacade<>((TimestampedWindowStore<Object, Object>)store); //} if (store is TimestampedKeyValueStore <K, V> && storeQueryParameters.QueryableStoreType is KeyValueStoreType <K, V> ) { T t = new ReadOnlyKeyValueStoreFacade <K, V>(store as TimestampedKeyValueStore <K, V>) as T; stores.Add(t); } else if (store is T) { stores.Add(store as T); } } } return(stores); }
public IEnumerable <T> Stores <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { // TODO: handle 'staleStoresEnabled' and 'partition' when they are added to StoreQueryParameters if (streamThread.State == ThreadState.DEAD) { yield break; } if (streamThread.State != ThreadState.RUNNING) { throw new InvalidStateStoreException($"Cannot get state store {storeQueryParameters.StoreName} because the stream thread is {streamThread.State}, not RUNNING"); } foreach (var streamTask in streamThread.ActiveTasks) { var store = Store(storeQueryParameters, streamTask); if (store != null) { yield return(store); } } }
/// <summary> /// Get a composite object wrapping the instances of the <see cref="Processors.IStateStore"/> with the provided /// storeName and <see cref="IQueryableStoreType{T, K, V}"/> /// </summary> /// <typeparam name="T">The expected type of the returned store</typeparam> /// <typeparam name="K">Key type</typeparam> /// <typeparam name="V">Value type</typeparam> /// <param name="storeQueryParameters">parameters to be used when querying for store</param> /// <returns>A composite object that wraps the store instances.</returns> public T GetStore <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { //IEnumerable<T> globalStore = this.globalStateStoreProvider.stores(storeName, queryableStoreType); //if (globalStore.Any()) //{ // return queryableStoreType.Create(new WrappingStoreProvider(new[] { this.globalStateStoreProvider })), storeName); //} IEnumerable <T> allStores = this.storeProviders .SelectMany(store => store.Stores(storeQueryParameters)); if (!allStores.Any()) { throw new InvalidStateStoreException($"The state store, {storeQueryParameters.StoreName}, may have migrated to another instance."); } return(storeQueryParameters .QueryableStoreType .Create( new WrappingStoreProvider <T, K, V>(this.storeProviders, storeQueryParameters), storeQueryParameters.StoreName)); }
/// <summary> /// Get a composite object wrapping the instances of the <see cref="Processors.IStateStore"/> with the provided /// storeName and <see cref="IQueryableStoreType{T, K, V}"/> /// </summary> /// <typeparam name="T">The expected type of the returned store</typeparam> /// <typeparam name="K">Key type</typeparam> /// <typeparam name="V">Value type</typeparam> /// <param name="storeQueryParameters">parameters to be used when querying for store</param> /// <returns>A composite object that wraps the store instances.</returns> public T GetStore <T, K, V>(StoreQueryParameters <T, K, V> storeQueryParameters) where T : class { IEnumerable <T> globalStore = globalStateStoreProvider.Stores(storeQueryParameters); if (globalStore.Any()) { return(storeQueryParameters.QueryableStoreType.Create(new GlobalStateStoreProviderFacade <T, K, V>(globalStateStoreProvider), storeQueryParameters.StoreName)); } IEnumerable <T> allStores = storeProviders .SelectMany(store => store.Stores(storeQueryParameters)); if (!allStores.Any()) { throw new InvalidStateStoreException($"The state store, {storeQueryParameters.StoreName}, may have migrated to another instance."); } return(storeQueryParameters .QueryableStoreType .Create( new WrappingStoreProvider <T, K, V>(storeProviders, storeQueryParameters), storeQueryParameters.StoreName)); }
public void GetKVStateStoreInvalidStateStoreException() { var timeout = TimeSpan.FromSeconds(10); var source = new CancellationTokenSource(); bool state = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; var builder = new StreamBuilder(); builder .Stream <string, string>("test") .GroupByKey() .Count(InMemory <string, long> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, new SyncKafkaSupplier()); stream.StateChanged += (old, @new) => { if ([email protected](KafkaStream.State.RUNNING)) { if (!state) { Assert.Throws <InvalidStateStoreException>(() => stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, long>()))); state = true; } } }; stream.Start(source.Token); while (!state) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(state); source.Cancel(); stream.Close(); }
public WrappingStoreProvider(IEnumerable <StreamThreadStateStoreProvider> storeProviders, StoreQueryParameters <T, K, V> storeQueryParameters) { this.storeProviders = storeProviders; this.storeQueryParameters = storeQueryParameters; }
public StoreQuery GenerateQuery(IQueryModel qc, StoreQueryParameters storeParameters = null) { try { var result = new StoreQuery(); if (storeParameters != null) { result.DataService = storeParameters.DataService; result.Name = storeParameters.QueryName; result.Namespace = storeParameters.Namespace; result.ReturnTypeName = storeParameters.QueryReturnType; result.SchemaFile = storeParameters.SchemaFileName; } else { result.Name = qc.Name; } result.SchemaName = qc.Schema?.Name; result.SchemaVersion = qc.Schema?.Version; result.Query = new StoreQueryDefinition(); result.Query.Fields = qc.SelectionProperties.ToDictionary( p => p.OutputName, p => new StoreQueryField { FieldAlias = p.OutputName, IsOutput = p.IsOutput, GroupByFunction = p.GroupByFunction, GroupByFilter = p.Having, Field = new StoreFieldReference { FieldName = p.StoreProperty.Name, ObjectAlias = p.FromTable.Alias } }); result.Query.Tables = qc.FromTables.ToDictionary( t => t.Alias, t => new StoreTableReference { ObjectAlias = t.Alias, TableName = t.Name, IsSubQuery = t.IsSubQuery } ); // ToDo: composite foreign keys not supported currently List <StoreObjectJoin> joins = qc.FromTableJoins.Where(f => !f.IsDeleted) .Select(f => { f.Source.JoinType = f.JoinType; return(f.Source); }).ToList(); result.Query.Joins = joins.ToArray(); var expr = _expressions.BuildExpressionTree(qc.WhereClause); var storeExpr = QueryExpressionHelper.ReadFromSqlExpr(expr); result.Query.Where = new StoreQueryCondition { Expression = storeExpr }; var paramsDict = QueryExpressionHelper.GetParamsFromSqlExpr(expr); result.Query.Parameters = paramsDict.ToDictionary(d => d.Key, d => new StoreQueryParameter { Name = d.Key, Type = FindStoreProperty(qc, d.Value)?.Type }); return(result); } catch (Exception exc) { //qc.Errors += "\r\n" + exc.Message; //return null; throw; } }
public async Task GetWindowElementInStateStore() { var timeout = TimeSpan.FromSeconds(10); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; config.PollMs = 10; var supplier = new SyncKafkaSupplier(); var producer = supplier.GetProducer(config.ToProducerConfig()); var builder = new StreamBuilder(); builder .Stream <string, string>("test") .GroupByKey() .WindowedBy(TumblingWindowOptions.Of(TimeSpan.FromMinutes(1))) .Count(InMemoryWindows <string, long> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, supplier); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; await stream.StartAsync(); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var serdes = new StringSerDes(); dt = DateTime.Now; producer.Produce("test", new Confluent.Kafka.Message <byte[], byte[]> { Key = serdes.Serialize("key1", new SerializationContext()), Value = serdes.Serialize("coucou", new SerializationContext()), Timestamp = new Confluent.Kafka.Timestamp(dt) }); Thread.Sleep(50); var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.WindowStore <string, long>())); Assert.IsNotNull(store); var @enum = store.All(); Assert.AreEqual(1, store.All().ToList().Count); var item = store.Fetch("key1", dt.AddMinutes(-1), dt.AddMinutes(1)); Assert.IsNotNull(item); Assert.IsTrue(item.MoveNext()); Assert.IsTrue(item.Current.HasValue); Assert.AreEqual(1, item.Current.Value.Value); item.Dispose(); } stream.Dispose(); }
public IEnumerable <T> Stores(string storeName, IQueryableStoreType <T, K, V> queryableStoreType) { return(this.globalStateStoreProvider.Stores(StoreQueryParameters.FromNameAndType(storeName, queryableStoreType))); }
public async Task GetRangeKVStateStore() { var timeout = TimeSpan.FromSeconds(10); bool isRunningState = false; DateTime dt = DateTime.Now; var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.BootstrapServers = "127.0.0.1"; config.PollMs = 10; var supplier = new SyncKafkaSupplier(); var producer = supplier.GetProducer(config.ToProducerConfig()); var builder = new StreamBuilder(); builder.Table("topic", InMemory <string, string> .As("store")); var t = builder.Build(); var stream = new KafkaStream(t, config, supplier); stream.StateChanged += (old, @new) => { if (@new.Equals(KafkaStream.State.RUNNING)) { isRunningState = true; } }; await stream.StartAsync(); while (!isRunningState) { Thread.Sleep(250); if (DateTime.Now > dt + timeout) { break; } } Assert.IsTrue(isRunningState); if (isRunningState) { var serdes = new StringSerDes(); producer.Produce("topic", new Confluent.Kafka.Message <byte[], byte[]> { Key = serdes.Serialize("key1", new SerializationContext()), Value = serdes.Serialize("coucou", new SerializationContext()) }); Thread.Sleep(50); var store = stream.Store(StoreQueryParameters.FromNameAndType("store", QueryableStoreTypes.KeyValueStore <string, string>())); Assert.IsNotNull(store); var list = store.Range("key1", "key2").ToList(); Assert.AreEqual(1, list.Count); var item = list[0]; Assert.IsNotNull(item); Assert.AreEqual("coucou", item.Value); Assert.AreEqual("key1", item.Key); } stream.Dispose(); }