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();
}
