public void Subscribe_LastPolled(int numberOfTicks)
{
var pollingInterval = TimeSpan.FromMilliseconds(100);
if (numberOfTicks == 0)
{
numberOfTicks++; // Polling is executed before first tick
}
var subscriptionTime = pollingInterval.Ticks * (numberOfTicks > 0 ? numberOfTicks : 1);
var scheduler = new TestScheduler();
int cont = 0;
IObservable <int> source = Observable.Create <int>(x =>
{
x.OnNext(Interlocked.Increment(ref cont));
x.OnCompleted();
return(Disposable.Empty);
});
ITestableObserver <int> observer = scheduler.CreateObserver <int>();
using (var sut = new PollingObservable <int>(source, pollingInterval, scheduler))
{
scheduler.AdvanceTo(subscriptionTime);
using (sut.Subscribe(observer))
{
scheduler.AdvanceBy(1);
}
}
observer.Messages.AssertEqual(
OnNext <int>(subscriptionTime + 1, x => x == numberOfTicks && cont == numberOfTicks + 1),
OnCompleted <int>(subscriptionTime + 1));
}
public void Subscribe_WaitToFirstTick_OneMessage()
{
long executionTicks = TimeSpan.FromMilliseconds(100).Ticks + 1;
var scheduler = new TestScheduler();
int cont = 0;
IObservable <int> source = Observable.Create <int>(x =>
{
scheduler.Sleep(executionTicks - 1);
x.OnNext(Interlocked.Increment(ref cont));
x.OnCompleted();
return(Disposable.Empty);
});
ITestableObserver <int> observer = scheduler.CreateObserver <int>();
using (var sut = new PollingObservable <int>(source, TimeSpan.FromHours(1), scheduler))
using (sut.Subscribe(observer))
{
scheduler.AdvanceTo(executionTicks);
}
observer.Messages.AssertEqual(
OnNext <int>(executionTicks, x => x == 1),
OnCompleted <int>(executionTicks));
}
public async Task Subscribe_Success()
{
TestObserver observer = new TestObserver()
{
ExpectedValueCount = 4
};
int current = 0;
Func <ByteString, Task <IReadOnlyList <ByteString> > > query = delegate(ByteString start)
{
List <ByteString> result = new List <ByteString>();
result.Add(new ByteString(new byte[] { (byte)current, 0 }));
result.Add(new ByteString(new byte[] { (byte)current, 1 }));
current++;
return(Task.FromResult <IReadOnlyList <ByteString> >(result));
};
IObservable <ByteString> stream = new PollingObservable(ByteString.Empty, query);
using (stream.Subscribe(observer))
await observer.Completed.Task;
await observer.Disposed.Task;
Assert.False(observer.Fail);
Assert.Equal(4, observer.Values.Count);
Assert.Equal(ByteString.Parse("0000"), observer.Values[0]);
Assert.Equal(ByteString.Parse("0001"), observer.Values[1]);
Assert.Equal(ByteString.Parse("0100"), observer.Values[2]);
Assert.Equal(ByteString.Parse("0101"), observer.Values[3]);
}
/// <summary>
/// Creates a new PollWatcher for synchronous polling methods
/// </summary>
/// <param name="pollingTarget">Function to poll for data</param>
/// <param name="pollingInterval">Interval at which to poll for data</param>
/// <param name="successHandler">Action to perform on retrieved data</param>
/// <param name="failureHandler">Action to perform on exceptions raised during polling</param>
/// <param name="schedulingStrategy">[default = SchedulingStrategy.ThreadPool] Thread scheduling strategy to utilize.</param>
public PollWatcher(Func <T> pollingTarget,
TimeSpan pollingInterval,
Action <T> successHandler,
Action <Exception> failureHandler,
SchedulingStrategy?schedulingStrategy = null)
{
PollingInterval = pollingInterval;
SuccessHandler = successHandler;
FailureHandler = failureHandler;
PollingTarget = pollingTarget;
Scheduler = schedulingStrategy.CreateScheduler();
SourceFactory = () => Observable.Return(PollingTarget());
PollingObservable = SourceFactory.Poll(PollingInterval, Scheduler);
PollSubscription = PollingObservable.Monitor(SuccessHandler, FailureHandler);
}
public void Subscribe_OverlappedTicks_OnlyFirstExecuted()
{
var executionDuration = TimeSpan.FromMilliseconds(300);
var scheduler = new TestScheduler();
int calls = 0;
IObservable <Unit> source = Observable.Create <Unit>(_ =>
{
Interlocked.Increment(ref calls);
scheduler.Sleep(executionDuration.Ticks);
return(Disposable.Empty);
});
using (var sut = new PollingObservable <Unit>(source, TimeSpan.FromMilliseconds(100), scheduler))
{
scheduler.AdvanceTo(executionDuration.Ticks);
}
calls.Should().Be(1);
}
/// <summary>
/// Handles an incoming HTTP request.
/// </summary>
/// <param name="context">The current HTTP context.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task Invoke(HttpContext context)
{
if (context.WebSockets.IsWebSocketRequest)
{
string from = context.Request.Query["from"];
ByteString lastLedgerRecordHash;
if (string.IsNullOrEmpty(from))
{
lastLedgerRecordHash = null;
}
else
{
lastLedgerRecordHash = ByteString.Parse(from);
}
ILogger logger = (ILogger)context.RequestServices.GetService(typeof(ILogger));
IStorageEngine store = (IStorageEngine)context.RequestServices.GetService(typeof(IStorageEngine));
await store.Initialize();
IObservable <ByteString> stream = new PollingObservable(lastLedgerRecordHash, store.GetTransactions);
using (WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync())
{
ArraySegment <byte> receiveBuffer = new ArraySegment <byte>(new byte[512]);
using (Observer observer = new Observer(webSocket, logger, context.RequestAborted))
{
using (stream.Subscribe(observer))
{
await Task.WhenAny(observer.Closed, webSocket.ReceiveAsync(receiveBuffer, context.RequestAborted));
}
await observer.Closed;
}
}
}
else
{
await this.next(context);
}
}
public void Subscribe_CancelledBeforeFirstResult_EmptyMessages()
{
long executionTicks = TimeSpan.FromMinutes(1).Ticks;
long waitingTicks = TimeSpan.FromMilliseconds(100).Ticks;
var scheduler = new TestScheduler();
IObservable <int> source = Observable.Create <int>(x =>
{
scheduler.Sleep(executionTicks);
return(Disposable.Empty);
});
ITestableObserver <int> observer = scheduler.CreateObserver <int>();
using (var sut = new PollingObservable <int>(source, TimeSpan.FromHours(1), scheduler))
using (sut.Subscribe(observer))
{
scheduler.AdvanceTo(waitingTicks);
}
scheduler.Clock.Should().Be(waitingTicks);
observer.Messages.Should().BeEmpty();
}
public async Task Subscribe_Error()
{
TestObserver observer = new TestObserver()
{
ExpectedValueCount = 1
};
Func <ByteString, Task <IReadOnlyList <ByteString> > > query = delegate(ByteString start)
{
return(Task.FromException <IReadOnlyList <ByteString> >(new ArithmeticException()));
};
IObservable <ByteString> stream = new PollingObservable(ByteString.Empty, query);
using (stream.Subscribe(observer))
await observer.Completed.Task;
await observer.Disposed.Task;
Assert.True(observer.Fail);
Assert.Equal(0, observer.Values.Count);
}
public void Subscribe_StartsImmediately()
{
long expectedTicks = 1;
var scheduler = new TestScheduler();
int cont = 0;
IObservable <int> source = Observable.Create <int>(x =>
{
x.OnNext(Interlocked.Increment(ref cont));
x.OnCompleted();
return(Disposable.Empty);
});
ITestableObserver <int> observer = scheduler.CreateObserver <int>();
using (var sut = new PollingObservable <int>(source, TimeSpan.FromHours(1), scheduler))
using (sut.Subscribe(observer))
{
scheduler.AdvanceTo(expectedTicks);
}
observer.Messages.AssertEqual(
OnNext <int>(expectedTicks, x => x == 1),
OnCompleted <int>(expectedTicks));
}
