public void ListPushTriggeredWithStart()
{
var outputValue = 0;
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var observable = PushObservable.FromEnumerable(new[] { 1 });
var task = observable.ToTaskAsync();
observable.Subscribe(i => outputValue = i);
observable.Start();
var res = task.Result;
Assert.AreEqual(1, outputValue);
Assert.AreEqual(1, res);
}
public void ListToListPushTriggeredWithEventWait()
{
var outputValue = 0;
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var observable = PushObservable.FromEnumerable(new[] { 1 }, waitHandle);
var task = observable.ToListAsync();
observable.Subscribe(i => outputValue = i);
waitHandle.Set();
var res = task.Result;
Assert.AreEqual(1, outputValue);
CollectionAssert.AreEquivalent(new[] { 1 }, res);
}
public void SinglePushTriggeredWithEventWait()
{
var outputValue = 0;
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var observable = PushObservable.FromSingle(1, waitHandle);
var task = observable.ToTaskAsync();
observable.Subscribe(i => outputValue = i);
waitHandle.Set();
var res = task.Result;
Assert.AreEqual(1, outputValue);
Assert.AreEqual(1, res);
}
public void UndistinctSortedValuesForDistinct()
{
var inputValues = new[] { -2, -1, -1, 0, 1, 2 };
var outputValues = new List <int>();
var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>();
var filtered = obs.ExceptionOnUnsorted(i => i, SortOrder.Ascending, true);
var output = filtered.ToListAsync();
var errorList = filtered.ExceptionsToObservable().ToListAsync();
obs.Start();
output.Wait();
errorList.Wait();
CollectionAssert.AreEquivalent(new[] { -2, -1, 0, 1, 2 }, output.Result, "the output should contains only sorted values");
Assert.AreEqual(1, errorList.Result.Count, "one exception should be issued");
}
public void SortedValues()
{
var inputValues = new[] { -2, -1, 0, 1, 2 };
var outputValues = new List <int>();
var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>();
var filtered = obs.ExceptionOnUnsorted(i => i);
var output = filtered.ToListAsync();
var errorList = filtered.ExceptionsToObservable().ToListAsync();
obs.Start();
output.Wait();
errorList.Wait();
CollectionAssert.AreEquivalent(inputValues, output.Result, "the output should be the same than the input");
Assert.AreEqual(0, errorList.Result.Count, "no exception should be issued in a sorted stream");
}
public void BigLoad()
{
int nb = 5000;
string example = "abcdefghijklmnopqrstuvwxyz";
var examples = Enumerable.Range(0, nb).Select(i => example).ToList();
var initObs = PushObservable.FromSingle(examples);
var task = initObs
.FlatMap(i => new DeferredPushObservable <string>(push => i.ForEach(push)))
.FlatMap(i => new DeferredPushObservable <char>(push => i.ToList().ForEach(push)))
.ToListAsync();
initObs.Start();
task.Wait(5000);
Assert.AreEqual(example.Count() * nb, task.Result.Count);
Assert.IsTrue(task.IsCompletedSuccessfully);
}
public void SimpleConcatenationWithEmptyBottomTopStartingFirst()
{
var obs1 = PushObservable.FromEnumerable(new[] { 1, 2 });
var obs2 = PushObservable.FromEnumerable(new int[] { });
var outputObs = obs1.Concatenate(obs2);
var outputTask = outputObs.ToListAsync();
obs1.Start();
obs2.Start();
outputTask.Wait();
var output = outputTask.Result;
CollectionAssert.AreEquivalent(new[] { 1, 2 }, output);
}
protected override IStream <TOut> CreateOutputStream(EfCoreSaveArgs <TInEf, TIn, TOut> args)
{
var ret = args.SourceStream.Observable
.Chunk(args.BatchSize)
.Map(i => i.Select(j => (Input: j, Entity: args.GetEntity(j))).ToList())
.Do(i =>
{
var dbContext = args.KeyedConnection == null
? this.ExecutionContext.DependencyResolver.Resolve <DbContext>()
: this.ExecutionContext.DependencyResolver.Resolve <DbContext>(args.KeyedConnection);
this.ExecutionContext.InvokeInDedicatedThreadAsync(dbContext, () => ProcessBatch(i, dbContext, args.BulkLoadMode)).Wait();
})
.FlatMap((i, ct) => PushObservable.FromEnumerable(i, ct))
.Map(i => args.GetOutput(i.Input, i.Entity));
return(base.CreateUnsortedStream(ret));
}
public Stream(ITraceMapper traceMapper, IExecutionContext executionContext, string sourceNodeName, IPushObservable <T> observable)
{
this.TraceMapper = traceMapper;
this.SourceNodeName = sourceNodeName;
this.ExecutionContext = executionContext;
this.Observable = observable.TakeUntil(executionContext.StopProcessEvent);
if (traceMapper != null)
{
this.TraceObservable =
PushObservable.Merge <ITraceContent>(
this.Observable.ExceptionsToObservable().Map(e => new UnhandledExceptionStreamTraceContent(e)),
this.Observable.Count().Map(count => new CounterSummaryStreamTraceContent(count)),
this.Observable.Map((e, i) => new RowProcessStreamTraceContent(i + 1, e))
).Map(i => traceMapper.MapToTrace(i, executionContext.NextTraceSequence()));
}
}
public Stream(ITracer tracer, IExecutionContext executionContext, string sourceNodeName, IPushObservable <T> observable)
{
this.Tracer = tracer;
this.SourceNodeName = sourceNodeName;
this.ExecutionContext = executionContext;
this.Observable = observable
.CompletesOnException(e => tracer.Trace(new UnhandledExceptionStreamTraceContent(e)))
.TakeUntil(executionContext.StopProcessEvents);
if (tracer != null)
{
PushObservable.Merge <ITraceContent>(
this.Observable.Count().Map(count => new CounterSummaryStreamTraceContent(count)),
this.Observable.Map((e, i) => new RowProcessStreamTraceContent(i + 1, e))
).Subscribe(tracer.Trace);
}
}
public void SimpleConcatenationWithEmptyBottomBottomStartingFirst()
{
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var obs1 = PushObservable.FromEnumerable(new[] { 1, 2 }, waitHandle);
var obs2 = PushObservable.FromEnumerable(new int[] { }, waitHandle);
var outputObs = obs1.Concatenate(obs2);
var outputTask = outputObs.ToListAsync();
waitHandle.Set();
// obs2.Start();
// obs1.Start();
outputTask.Wait();
var output = outputTask.Result;
CollectionAssert.AreEquivalent(new[] { 1, 2 }, output);
}
public void RangeOfValuesNotAutomaticallyStartsOnHandle(int start, int nb)
{
var expectedValues = Enumerable.Range(start, nb).ToList();
var outputValues = new List <int>();
var obs = PushObservable.Range(-5, nb);
obs.Subscribe(outputValues.Add);
var task = obs.ToTaskAsync();
obs.Start();
Assert.IsTrue(task.Wait(5000), "the stream should complete");
for (int i = 0; i < nb; i++)
{
Assert.AreEqual(start + i, outputValues[i], "all values should be the same");
}
Assert.AreEqual(nb, outputValues.Count, "nb items from the input source must be the same that in the output");
}
public void SeveralUnSortedElements()
{
var inputValues = new int[] { 4, 1, 2, 5, 0, 3 };
var outputValues = new List <int>();
var obs = PushObservable.FromEnumerable(inputValues);
var task = obs.Aggregate((i) => new List <int>(), i => i % 3, (a, i) => a.Union(new[] { i }).ToList(), (i, k, a) => new { Key = k, Value = a }).ToListAsync();
obs.Start();
task.Wait();
Assert.AreEqual(3, task.Result.Count, "the output stream should have one element");
CollectionAssert.AreEquivalent(new[] { 4, 1 }, task.Result[0].Value);
Assert.AreEqual(1, task.Result[0].Key);
CollectionAssert.AreEquivalent(new[] { 2, 5 }, task.Result[1].Value);
Assert.AreEqual(2, task.Result[1].Key);
CollectionAssert.AreEquivalent(new[] { 0, 3 }, task.Result[2].Value);
Assert.AreEqual(0, task.Result[2].Key);
}
public void RangeOfValues(int start, int nb, int top)
{
var outputValues = new List <int>();
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var obs = PushObservable.Range(start, nb, waitHandle).Take(top);
obs.Subscribe(outputValues.Add);
var task = obs.ToTaskAsync();
waitHandle.Set();
task.Wait(5000);
for (int i = 0; i < top; i++)
{
Assert.AreEqual(start + i, outputValues[i], "all values should be the same");
}
Assert.AreEqual(top, outputValues.Count, $"nb items from the output must be {top}");
}
public void RangeOfValues(int start, int nb, int skip)
{
var outputValues = new List <int>();
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var obs = PushObservable.Range(start, nb, waitHandle).Skip(skip);
obs.Subscribe(outputValues.Add);
var task = obs.ToTaskAsync();
waitHandle.Set();
task.Wait(5000);
for (int i = 0; i < (nb - skip); i++)
{
Assert.AreEqual(start + i + skip, outputValues[i], "all values should be the same");
}
Assert.AreEqual(nb - skip, outputValues.Count, $"nb items from the output must be the same that in the input except the {skip}th ones");
}
public void DistinctSortedValuesForDistinct()
{
var inputValues = new[] { -2, -1, 0, 1, 2 };
var outputValues = new List <int>();
var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>();
var filtered = obs.ExceptionOnUnsorted(i => i, SortOrder.Ascending, true);
var output = filtered.ToListAsync();
var errorList = filtered.ExceptionsToObservable().ToListAsync();
obs.Start();
output.Wait();
errorList.Wait();
// Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
// Trace.WriteLine(string.Join(',', output.Result.Select(i => i.ToString())));
// Trace.WriteLine(errorList.Result.Count);
Assert.AreEqual(0, errorList.Result.Count, "no exception should be issued in a sorted stream");
Assert.AreEqual(inputValues.Length, output.Result.Count, "the output should be the same size than the input");
CollectionAssert.AreEquivalent(inputValues, output.Result, "the output should be the same than the input");
}
public void FlatMapWithDeferable()
{
var valueStack = new Stack <int>();
var errorStack = new Stack <Exception>();
bool isComplete = false;
var obs = new PushSubject <int>();
var sobs = new[] { PushObservable.FromEnumerable(new[] { 1, 2 }), PushObservable.FromEnumerable(new[] { 3, 4 }) };
var output = obs.FlatMap(i => sobs[i]);
output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push);
obs.PushValue(0);
System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued
CollectionAssert.AreEquivalent(new[] { 1, 2 }, valueStack, "output values should be automatically issued");
obs.PushValue(1);
System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, valueStack, "output values should be automatically issued");
obs.Complete();
Assert.IsTrue(isComplete, "the output stream should be completed");
}
protected override IStream <TOut> CreateOutputStream(ToSubProcessesArgs <TIn, TOut> args)
{
// Semaphore semaphore = args.NoParallelisation ? new Semaphore(1, 1) : new Semaphore(10, 10);
Synchronizer synchronizer = new Synchronizer(args.NoParallelisation);
if (this.ExecutionContext is GetDefinitionExecutionContext)
{
var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(default(TIn)));
foreach (var subProcess in args.SubProcesses)
{
var outputStream = subProcess(inputStream);
this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable);
}
}
var outputObservable = args.Stream.Observable
.FlatMap(i => PushObservable.FromEnumerable(args.SubProcesses.Select(sp => new
{
config = i,
subProc = sp
})))
.FlatMap(i =>
{
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(i.config, waitHandle));
var outputStream = i.subProc(inputStream);
IDisposable awaiter = null;
outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose());
return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () =>
{
awaiter = synchronizer.WaitBeforeProcess();
waitHandle.Set();
}));
});
return(base.CreateUnsortedStream(outputObservable));
}
protected override IStream <TOut> CreateOutputStream(SubProcessArgs <TIn, TOut> args)
{
if (this.ExecutionContext is GetDefinitionExecutionContext)
{
var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(default(TIn), args.Stream.Observable.CancellationToken));
var outputStream = args.SubProcess(inputStream);
// this.ExecutionContext.AddNode(this, outputStream.Observable);
}
Synchronizer synchronizer = new Synchronizer(args.NoParallelisation);
var outputObservable = args.Stream.Observable
.FlatMap((i, ct) =>
{
// TODO: Solve bug here (this operator makes the process freezing))
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var inputStream = new SingleStream <TIn>(new SubNodeWrapper(this), PushObservable.FromSingle(i, waitHandle, ct));
var outputStream = args.SubProcess(inputStream);
// this.ExecutionContext.AddNode(this, outputStream.Observable);
IDisposable awaiter = null;
outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose());
return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () =>
{
awaiter = synchronizer.WaitBeforeProcess();
waitHandle.Set();
}, null, ct));
});
return(base.CreateUnsortedStream(outputObservable));
}
protected override IStream <TOut> CreateOutputStream(SubProcessArgs <TIn, TOut> args)
{
if (this.ExecutionContext is GetDefinitionExecutionContext)
{
var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(default(TIn)));
var outputStream = args.SubProcess(inputStream);
this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable);
}
Synchronizer synchronizer = new Synchronizer(args.NoParallelisation);
var outputObservable = args.Stream.Observable
.FlatMap(i =>
{
EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(i, waitHandle));
var outputStream = args.SubProcess(inputStream);
this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable);
IDisposable awaiter = null;
outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose());
return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () =>
{
awaiter = synchronizer.WaitBeforeProcess();
waitHandle.Set();
}));
});
return(base.CreateUnsortedStream(outputObservable));
}
protected override IStream <TOut> CreateOutputStream(UnpivotArgs <TIn, TUnpivoted, TOut> args)
{
return(base.CreateUnsortedStream(args.InputStream.Observable.FlatMap(i => PushObservable.FromEnumerable(args.FieldsToUnpivot.Select(inp => args.ResultSelector(i, inp(i)))))));
}
protected override IStream <Correlated <TOut> > CreateOutputStream(GroupByCorrelatedArgs <TIn, TKey, TOut> args)
{
if (this.ExecutionContext is GetDefinitionExecutionContext)
{
var inputStream = new SingleStream <Correlated <TIn> >(new SubNodeWrapper(this), PushObservable.FromSingle(default(Correlated <TIn>), null, args.Stream.Observable.CancellationToken));
var outputStream = args.SubProcess(inputStream, default);
this.ExecutionContext.AddNode(this, outputStream.Observable);
}
var outputObservable = args.Stream.Observable.Group(i => args.GetKey(i.Row), (iS, firstElement) => args.SubProcess(new Stream <Correlated <TIn> >(new SubNodeWrapper(this), iS), firstElement.Row).Observable);
return(base.CreateUnsortedStream(outputObservable));
}
protected override IStream <TOut> CreateOutputStream(GroupArgs <TIn, TKey, TOut> args)
{
if (this.ExecutionContext is GetDefinitionExecutionContext)
{
var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(default(TIn)));
var outputStream = args.SubProcess(inputStream);
this.ExecutionContext.AddNode(this, outputStream.Observable, outputStream.TraceObservable);
}
var outputObservable = args.Stream.Observable.Group(args.GetKey, iS => args.SubProcess(new Stream <TIn>(this.Tracer.GetSubTraceMapper(this), this.ExecutionContext, this.NodeName, iS)).Observable);
return(base.CreateUnsortedStream(outputObservable));
}