private void ReleaseForDisposedFiberInternal(IFiber fiber)
{
if ((_executingEntityFiberManager != null && _executingEntityFiberManager != this) || !Monitor.TryEnter(_executionLock, 1))
{
_applicationFiber.Enqueue(() => ReleaseForDisposedFiberInternal(fiber));
return;
}
try
{
//lock (_enqueueLock)
//{
if (_currentFiber != fiber)
{
return;
}
_currentFiber = null;
Thread.MemoryBarrier(); // do not reorder!
if (_actions != null)
{
_applicationFiber.Enqueue(() => Execute(null));
}
//}
}
finally
{
Monitor.Exit(_executionLock);
}
}
public void Enter(ActorPeer peer)
{
_executionFiber.Enqueue(() =>
{
ListPeer.Add(peer);
SpawnPlayer(peer);
});
}
public void PeerJoined(StarCollectorDemoPeer peer)
{
// schedule peer to be added to PeerList on the main thread
executionFiber.Enqueue(() =>
{
PeerList.Add(peer);
});
}
public void Signal()
{
if (Interlocked.CompareExchange(ref _flushPending, 1, 0) == 1)
{
return;
}
_target.Enqueue(_cache);
}
public void Signal()
{
lock (this)
{
if (_flushPending)
{
return;
}
_flushPending = true;
_target.Enqueue(_cache);
}
}
protected override object Invoke(MethodInfo targetMethod, object[] args)
{
if (targetMethod == null)
{
throw new ArgumentException(nameof(targetMethod));
}
string targetMethodName = targetMethod.Name;
if (targetMethodName == "Dispose")
{
Dispose();
return(targetMethod.Invoke(_decorated, args));
}
//Handle event attach.detach
if (targetMethod.ReturnType != typeof(void) ||
targetMethodName.StartsWith("add_", StringComparison.Ordinal) ||
targetMethodName.StartsWith("remove_", StringComparison.Ordinal))
{
return(targetMethod.Invoke(_decorated, args));
}
_fiber.Enqueue(() => targetMethod.Invoke(_decorated, args));
return(null);
}
private void Run()
{
while (_running)
{
try
{
NetMQMessage msg = _replySocket.ReceiveMessage();
if (msg.IsEmpty)
{
continue;
}
if (msg.FrameCount != 3)
{
throw new Exception("Msg error");
}
var guid = new Guid(msg[1].Buffer);
if (!_requests.ContainsKey(guid))
{
throw new Exception("We don't have a msg SenderId for this reply");
}
TReply reply = _replyUnmarshaller(msg[2].Buffer);
_fiber.Enqueue(() => Send(guid, reply));
}
catch (Exception e)
{
_running = false;
}
}
InternalDispose();
}
public static void InOrderExecution(IFiber fiber)
{
using (fiber)
using (var reset = new AutoResetEvent(false))
{
int count = 0;
var result = new List <int>();
void Command()
{
result.Add(count++);
if (count == 100)
{
reset.Set();
}
}
for (int i = 0; i < 100; i++)
{
fiber.Enqueue(Command);
}
Assert.IsTrue(reset.WaitOne(10000, false));
Assert.AreEqual(100, count);
}
}
public void Run(IFiber fiber)
{
i = 0;
for (int j = 0; j < 1000000; j++)
{
fiber.Enqueue(Handler);
}
WaitHandle.WaitAny(new WaitHandle[] { _wait });
}
public IDisposable Schedule(IFiber fiber, Action action, TimeSpan dueTime)
{
if (dueTime.TotalMilliseconds <= 0)
{
var pending = new PendingAction(action);
fiber.Enqueue(pending.Execute);
return(pending);
}
return(new TimerAction(fiber, action, dueTime));
}
private void ExecuteOnTimerThread(IFiber fiber)
{
if (_interval.Ticks == TimeSpan.FromMilliseconds(-1).Ticks || _cancelled)
{
fiber.Remove(this);
DisposeTimer();
}
if (!_cancelled)
fiber.Enqueue(Execute);
}
public void Publish(TSnapshot msg)
{
if (_disposed)
{
return;
}
_fiber.Enqueue(() => _receiveSnapshot(msg));
//publishing the snapshot subscribes the updates...
_sub = _updatesPort.Subscribe(_fiber, _receive);
}
public IDisposable Schedule(IFiber fiber, Action action, TimeSpan dueTime)
{
if (dueTime.TotalMilliseconds <= 0)
{
var pending = new PendingAction(action);
fiber.Enqueue(pending.Execute);
return pending;
}
return new TimerAction(fiber, action, dueTime);
}
public static void ExecuteOnlyAfterStart(IFiber fiber)
{
using (fiber)
using (var reset = new AutoResetEvent(false))
{
fiber.Enqueue(() => reset.Set());
Assert.IsFalse(reset.WaitOne(1, false));
fiber.Start();
Assert.IsTrue(reset.WaitOne(1000, false));
}
}
public IDisposable Subscribe(IFiber fiber, Action <T> receive)
{
void Receive(T msg)
{
fiber.Enqueue(() => receive(msg));
}
IDisposable disposable = _internalEvent.Subscribe(Receive);
return(new Unsubscriber(disposable, fiber));
}
public IDisposable Subscribe(IFiber fiber, Action receive)
{
void Action()
{
fiber.Enqueue(receive);
}
IDisposable disposable = _internalEvent.Subscribe(Action);
return(new Unsubscriber(disposable, fiber));
}
public static void ExecuteOnlyAfterStart(IFiber fiber)
{
using (fiber)
using (var reset = new AutoResetEvent(false))
{
fiber.Enqueue(() => reset.Set());
Assert.IsFalse(reset.WaitOne(1, false));
fiber.Start();
Assert.IsTrue(reset.WaitOne(1000, false));
}
}
protected void Cleanup()
{
ClientFiber.Enqueue(() =>
{
Send.Dispose();
Context1.Dispose();
Subscriber.Dispose();
Context2.Dispose();
});
Thread.Sleep(100);
ClientFiber.Dispose();
}
private void ExecuteOnTimerThread(IFiber fiber)
{
if (_interval.Ticks == TimeSpan.FromMilliseconds(-1).Ticks || _cancelled)
{
fiber.Remove(this);
DisposeTimer();
}
if (!_cancelled)
{
fiber.Enqueue(Execute);
}
}
public IDisposable Subscribe(IFiber fiber, Action <T> handler)
{
lock (_lock)
{
IDisposable disposable = _updateChannel.Subscribe(fiber, handler);
if (_hasValue)
{
T item = _last;
fiber.Enqueue(() => handler(item));
}
return(disposable);
}
}
public IDisposable Subscribe(IFiber fiber, Action <T> handler)
{
lock (_lock)
{
IDisposable disposable = _updateChannel.Subscribe(fiber, handler);
int length = _list.Count;
for (int index = 0; index < length; index++)
{
T item = _list[index];
fiber.Enqueue(() => handler(item));
}
return(disposable);
}
}
public void PeerJoined(StarCollectorDemoPeer peer)
{
// schedule peer to be added to PeerList on the main thread
executionFiber.Enqueue(() =>
{
PeerList.Add(peer);
// send player CreateActor events for all players and stars
foreach (Player p in Players)
{
EventData evt = new EventData((byte)StarCollectorEventTypes.CreateActor);
evt.Parameters = new Dictionary <byte, object>();
evt.Parameters[0] = p.ActorType;
evt.Parameters[1] = p.ActorID;
evt.Parameters[2] = p.PosX;
evt.Parameters[3] = p.PosY;
evt.Parameters[4] = (p.Owner as StarCollectorDemoPeer).PlayerID;
peer.SendEvent(evt, new SendParameters());
}
foreach (Star s in Stars)
{
EventData evt = new EventData((byte)StarCollectorEventTypes.CreateActor);
evt.Parameters = new Dictionary <byte, object>();
evt.Parameters[0] = s.ActorType;
evt.Parameters[1] = s.ActorID;
evt.Parameters[2] = s.PosX;
evt.Parameters[3] = s.PosY;
peer.SendEvent(evt, new SendParameters());
}
SpawnPlayer(peer);
});
}
protected void Cleanup()
{
ClientFiber.Enqueue(() =>
{
Console.WriteLine("Dispose push");
Push.Dispose();
Context2.Dispose();
Thread.Sleep(10);
Console.WriteLine("Dispose pull");
Pull.Dispose();
Context1.Dispose();
Thread.Sleep(10);
});
Thread.Sleep(200);
ClientFiber.Dispose();
}
/// <summary>
/// Subscribe with a message predicate to filter messages
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="port"></param>
/// <param name="fiber"></param>
/// <param name="receive"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static IDisposable Subscribe <T>(this ISubscriberPort <T> port,
IFiber fiber,
Action <T> receive,
Predicate <T> filter)
{
Action <T> filteredReceiver = x =>
{
if (filter(x))
{
fiber.Enqueue(() => receive(x));
}
};
//we use a stub fiber to force the filtering onto the publisher thread.
return(port.Subscribe(StubFiber.StartNew(), filteredReceiver));
}
protected void Cleanup()
{
ClientFiber.Enqueue(() =>
{
Client.Dispose();
ClientContext.Dispose();
Thread.Sleep(10);
Service.Dispose();
ServerContext.Dispose();
});
Thread.Sleep(100);
Console.WriteLine("Dispose client fiber");
ClientFiber.Dispose();
Console.WriteLine("Dispose service");
ServerFiber.Dispose();
}
/// <summary>
/// Subscribe with a message predicate to filter messages
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="port"></param>
/// <param name="fiber"></param>
/// <param name="receive"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static IDisposable Subscribe <T>(this IFiber fiber,
ISubscriberPort <T> port,
Action <T> receive,
Predicate <T> filter)
{
void FilteredReceiver(T x)
{
if (filter(x))
{
fiber.Enqueue(() => receive(x));
}
}
IDisposable sub = port.Subscribe(FilteredReceiver);
return(new Unsubscriber(sub, fiber));
}
/// <summary>
/// Subscribe a fiber to an Action based event.
/// </summary>
/// <param name="fiber"></param>
/// <param name="obj"></param>
/// <param name="eventName"></param>
/// <param name="receive"></param>
/// <returns></returns>
public static IDisposable SubscribeToEvent(this IFiber fiber, object obj, string eventName,
Action receive)
{
EventInfo evt = obj.GetType().GetEvent(eventName);
MethodInfo add = evt.GetAddMethod();
MethodInfo remove = evt.GetRemoveMethod();
void Action()
{
fiber.Enqueue(receive);
}
object[] addHandlerArgs = { (Action)Action };
add.Invoke(obj, addHandlerArgs);
return(new Unsubscriber(new DisposeAction(() => remove.Invoke(obj, addHandlerArgs)), fiber));
}
/// <summary>
/// Subscribe with a message predicate to filter messages
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="port"></param>
/// <param name="fiber"></param>
/// <param name="receive"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static IDisposable Subscribe <T>(this IFiber fiber,
ISubscriberPort <T> port,
Action <T> receive,
Predicate <T> filter)
{
void FilteredReceiver(T x)
{
if (filter(x))
{
fiber.Enqueue(() => receive(x));
}
}
//we use a stub fiber to force the filtering onto the publisher thread.
var stub = StubFiber.StartNew();
port.Subscribe(stub, FilteredReceiver);
return(stub);
}
public static void InOrderExecution(IFiber fiber)
{
using (fiber)
using (var reset = new AutoResetEvent(false))
{
int count = 0;
var result = new List<int>();
Action command = () =>
{
result.Add(count++);
if (count == 100)
reset.Set();
};
for (int i = 0; i < 100; i++)
fiber.Enqueue(command);
Assert.IsTrue(reset.WaitOne(10000, false));
Assert.AreEqual(100, count);
}
}
//0 allocations when caching the handler to Action
public void Run2(IFiber fiber)
{
using AutoResetEvent wait = new AutoResetEvent(false);
using (fiber)
{
int i = 0;
Action handler = () =>
{
i++;
if (i == OperationsPerInvoke)
{
wait.Set();
}
};
for (int j = 0; j < OperationsPerInvoke; j++)
{
fiber.Enqueue(handler);
}
WaitHandle.WaitAny(new WaitHandle[] { wait });
}
}
/// <summary>
/// Receives the action and queues the execution on the target fiber.
/// </summary>
/// <param name="msg"></param>
protected override void OnMessageOnProducerThread(T msg)
{
_fiber.Enqueue(() => _receiver(msg));
}
public void GetAccount(string applicationId, IFiber fiber, Action <ApplicationAccount> callback)
{
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (fiber == null)
{
throw new ArgumentNullException("fiber");
}
var tmp = callback;
callback = account => fiber.Enqueue(() => tmp(account));
if (applicationId == null)
{
if (log.IsDebugEnabled)
{
log.Debug("Failed to authenticate. Application id is null.");
}
callback(new ApplicationAccount(string.Empty, AccountServiceResult.Error, false, ErrorMessages.AppIdMissing));
return;
}
applicationId = applicationId.Trim();
if (string.IsNullOrEmpty(applicationId))
{
if (log.IsDebugEnabled)
{
log.Debug("Failed to authenticate. app id is Empty");
}
callback(new ApplicationAccount(string.Empty, AccountServiceResult.Error, false, ErrorMessages.EmptyAppId));
return;
}
string appId;
if (!this.accountService.FormatApplicationId(applicationId, out appId))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Failed to authenticate. Invalid application id format: {0}", applicationId);
}
callback(new ApplicationAccount(string.Empty, AccountServiceResult.Error, false, ErrorMessages.InvalidAppIdFormat));
return;
}
CachedResult result;
using (Lock.TryEnter(this.dictionary, 10000))
{
if (!this.dictionary.TryGetValue(appId, out result))
{
log.DebugFormat("Create cached auth result for app: {0}", appId);
result = new CachedResult(this, appId, this.refreshInterval);
this.dictionary.Add(appId, result);
}
}
result.GetResult(callback);
}
public void BusyWait()
{
_busyWait.Enqueue(_lambda);
}
public void Sleep()
{
_sleep.Enqueue(_lambda);
}
