public void AsyncTimer_PollInterval()
{
DateTime start = SysTime.Now;
object state;
IAsyncResult ar;
ar = AsyncTimer.BeginTimer(TimeSpan.FromSeconds(1), null, "4");
state = ar.AsyncState;
AsyncTimer.EndTimer(ar);
Assert.IsTrue(SysTime.Now - start >= TimeSpan.FromSeconds(1) - SysTime.Resolution);
Assert.AreEqual("4", state);
AsyncTimer.PollInterval = TimeSpan.FromSeconds(1);
start = SysTime.Now;
ar = AsyncTimer.BeginTimer(TimeSpan.FromSeconds(1), null, "5");
state = ar.AsyncState;
AsyncTimer.EndTimer(ar);
Assert.IsTrue(SysTime.Now - start >= TimeSpan.FromSeconds(1) - SysTime.Resolution);
Assert.AreEqual("5", state);
}
private void Initialize()
{
// Basic initialization
ChannelHost.Start();
hostStarted = true;
channels = new Dictionary <string, TInternal>();
channelQueue = new LimitedQueue <TInternal>(maxAcceptedChannels);
acceptQueue = new Queue <AsyncResult <TInternal, object> >();
waitQueue = new Queue <AsyncResult <bool, object> >();
// Register the endpoint with the router.
SessionHandlerInfo sessionInfo;
sessionInfo = this.GetSessionHandlerInfo();
sessionMode = sessionInfo != null && sessionInfo.SessionType == typeof(DuplexSession);
if (sessionMode)
{
ChannelHost.Router.Dispatcher.AddLogical(new MsgHandlerDelegate(OnReceive), ep, typeof(DuplexSessionMsg), false, sessionInfo);
}
else
{
ChannelHost.Router.Dispatcher.AddLogical(new MsgHandlerDelegate(OnReceive), ep, typeof(WcfEnvelopeMsg), false, sessionInfo);
}
// Start the background task timer
arBkTimer = AsyncTimer.BeginTimer(bkTaskInterval, onBkTask, null);
}
public void AsyncTimer_CancelAll()
{
DateTime start = SysTime.Now;
IAsyncResult ar1, ar2;
ar1 = AsyncTimer.BeginTimer(TimeSpan.FromSeconds(20), null, null);
ar2 = AsyncTimer.BeginTimer(TimeSpan.FromSeconds(30), null, null);
Thread.Sleep(5000);
AsyncTimer.CancelTimer(ar1);
AsyncTimer.CancelTimer(ar2);
try
{
AsyncTimer.EndTimer(ar1);
Assert.Fail("Expected a CancelException");
AsyncTimer.EndTimer(ar2);
Assert.Fail("Expected a CancelException");
}
catch (CancelException)
{
}
Assert.IsTrue(SysTime.Now >= start + TimeSpan.FromSeconds(5) - SysTime.Resolution);
Assert.IsTrue(SysTime.Now <= start + TimeSpan.FromSeconds(6) - SysTime.Resolution);
}
/// <summary>
/// Internal background task method.
/// </summary>
/// <param name="state">Not used.</param>
private void OnBkTask(object state)
{
DateTime now = SysTime.Now;
AsyncTimer.EndTimer(arBkTimer);
using (TimedLock.Lock(this))
{
try
{
// Give derived classes a chance to perform any necessary
// background tasks.
OnBkTask();
}
catch (Exception e)
{
SysLog.LogException(e);
}
finally
{
// Schedule the next timer if this functionality is
// still enabled.
if (onBkTask != null)
{
arBkTimer = AsyncTimer.BeginTimer(bkTaskInterval, onBkTask, null);
}
}
}
}
public void AsyncTimer_Callback()
{
DateTime start = SysTime.Now;
fireTime = start;
AsyncTimer.BeginTimer(TimeSpan.FromSeconds(1), new AsyncCallback(OnTimer), "1");
Thread.Sleep(2000);
Assert.IsTrue(SysTime.Now - start >= TimeSpan.FromSeconds(1) - SysTime.Resolution);
Assert.AreEqual("1", state);
}
/// <summary>
/// Internal channel initialization.
/// </summary>
private void Initialize()
{
using (TimedLock.Lock(this))
{
// Start the background task timer if required.
bkTaskInterval = GetBackgroundTaskInterval();
if (bkTaskInterval > TimeSpan.Zero)
{
arBkTimer = AsyncTimer.BeginTimer(bkTaskInterval, onBkTask, null);
}
}
}
public void AsyncTimer_Implicit_Wait()
{
DateTime start = SysTime.Now;
object state;
IAsyncResult ar;
ar = AsyncTimer.BeginTimer(TimeSpan.FromSeconds(1), null, "3");
state = ar.AsyncState;
AsyncTimer.EndTimer(ar);
Assert.IsTrue(SysTime.Now - start >= TimeSpan.FromSeconds(1) - SysTime.Resolution);
Assert.AreEqual("3", state);
}
/// <summary>
/// Executed on a worker thread to look for timed-out accept and wait requests.
/// </summary>
/// <param name="state">Not used.</param>
private void OnBkTask(object state)
{
DateTime now = SysTime.Now;
AsyncTimer.EndTimer(arBkTimer);
using (TimedLock.Lock(this))
{
try
{
// Give derived classes a chance to perform any necessary
// background tasks.
OnBkTask();
// Scan the queued accept requests for any that have timed-out.
if (acceptQueue != null && acceptQueue.Count > 0)
{
do
{
AsyncResult <TInternal, object> arAccept;
arAccept = acceptQueue.Peek();
if (arAccept.TTD <= now)
{
acceptQueue.Dequeue();
arAccept.Notify(new TimeoutException());
}
else
{
break;
}
} while (acceptQueue.Count > 0);
}
// Scan the queued wait requests for any that have timed-out.
if (waitQueue != null && waitQueue.Count > 0)
{
do
{
AsyncResult <bool, object> arWait;
arWait = waitQueue.Peek();
if (arWait.TTD <= now)
{
waitQueue.Dequeue();
arWait.Notify(new TimeoutException());
}
else
{
break;
}
} while (waitQueue.Count > 0);
}
}
catch (Exception e)
{
SysLog.LogException(e);
}
finally
{
// Schedule the next timer if this functionality is
// still enabled.
if (onBkTask != null)
{
arBkTimer = AsyncTimer.BeginTimer(bkTaskInterval, onBkTask, null);
}
}
}
}
public void SipBasicCore_Request_ReplyAsync()
{
// Verify that we can submit a non-dialog request from
// one core to another, respond to it asynchronously and
// then verify that we actually received the response.
StartCores();
try
{
SipResponse core1Response = null;
core1.ResponseReceived += delegate(object sender, SipResponseEventArgs args)
{
core1Response = args.Response;
};
SipRequest core2Request = null;
core2.RequestReceived += delegate(object sender, SipRequestEventArgs args)
{
SipResponse reply;
core2Request = args.Request;
reply = core2Request.CreateResponse(SipStatus.OK, "Hello World!");
reply.Contents = new byte[] { 5, 6, 7, 8 };
args.WillRespondAsynchronously = true;
AsyncCallback callback = delegate(IAsyncResult ar)
{
AsyncTimer.EndTimer(ar);
args.Transaction.SendResponse(reply);
};
AsyncTimer.BeginTimer(TimeSpan.FromMilliseconds(100), callback, null);
};
// Submit a request and verify the response.
SipRequest request;
SipResult result;
SipResponse response;
request = new SipRequest(SipMethod.Info, (string)core2Uri, null);
request.Contents = new byte[] { 1, 2, 3, 4 };
result = core1.Request(request);
response = result.Response;
Assert.AreEqual(SipStatus.OK, result.Status);
Assert.AreEqual(SipStatus.OK, response.Status);
Assert.AreEqual("Hello World!", response.ReasonPhrase);
CollectionAssert.AreEqual(new byte[] { 5, 6, 7, 8 }, response.Contents);
// Verify that the core1 ResponseReceived event handler was called
Assert.IsNotNull(core1Response);
Assert.AreEqual(SipStatus.OK, core1Response.Status);
Assert.AreEqual("Hello World!", core1Response.ReasonPhrase);
CollectionAssert.AreEqual(new byte[] { 5, 6, 7, 8 }, core1Response.Contents);
// Verify that the core2 RequestReceived event handler was called
Assert.IsNotNull(core2Request);
Assert.AreEqual(SipMethod.Info, core2Request.Method);
CollectionAssert.AreEqual(new byte[] { 1, 2, 3, 4 }, core2Request.Contents);
}
finally
{
StopCores();
}
}
public void OnAsyncMsg_Infinite(AsyncMsg msg)
{
AsyncTimer.BeginTimer(TimeSpan.FromSeconds(20), new AsyncCallback(OnAsyncDone), new AsyncState(msg._Session.Router, msg._Session, msg));
}
