/// <summary>
/// TBD
/// </summary>
/// <param name="systemMessage">TBD</param>
public override void SendSystemMessage(ISystemMessage systemMessage)
{
var failed = systemMessage as Failed;
if (failed != null)
{
var cause = failed.Cause;
var child = failed.Child;
_log.Error(cause, "guardian {0} failed, shutting down!", child);
CauseOfTermination = cause;
((IInternalActorRef)child).Stop();
return;
}
var supervise = systemMessage as Supervise;
if (supervise != null)
{
// This comment comes from AKKA: TO DO register child in some map to keep track of it and enable shutdown after all dead
return;
}
var deathWatchNotification = systemMessage as DeathWatchNotification;
if (deathWatchNotification != null)
{
Stop();
return;
}
_log.Error("{0} received unexpected system message [{1}]", _path, systemMessage);
}
/// <summary>
/// Sends the system message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendSystemMessage(ISystemMessage message)
{
try
{
//send to remote, unless watch message is intercepted by the remoteWatcher
var watch = message as Watch;
if (watch != null && IsWatchIntercepted(watch.Watchee, watch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.WatchRemote(watch.Watchee, watch.Watcher));
}
else
{
var unwatch = message as Unwatch;
if (unwatch != null && IsWatchIntercepted(unwatch.Watchee, unwatch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.UnwatchRemote(unwatch.Watchee,
unwatch.Watcher));
}
else
{
Remote.Send(message, null, this);
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
private void SendSystemMessage(ISystemMessage systemMessage)
{
_stopped.IfOff(() =>
{
var failed = systemMessage as Failed;
if(failed != null)
{
var cause = failed.Cause;
var child = failed.Child;
_log.Error(cause, "guardian {0} failed, shutting down!", child);
CauseOfTermination = cause;
((IInternalActorRef) child).Stop();
return;
}
var supervise = systemMessage as Supervise;
if(supervise != null)
{
// This comment comes from AKKA: TO DO register child in some map to keep track of it and enable shutdown after all dead
return;
}
var deathWatchNotification = systemMessage as DeathWatchNotification;
if(deathWatchNotification != null)
{
Stop();
return;
}
_log.Error("{0} received unexpected system message [{1}]",_path,systemMessage);
});
}
/// <summary>
/// Afters the send system message.
/// </summary>
/// <param name="message">The message.</param>
public void AfterSendSystemMessage(ISystemMessage message)
{
message.Match()
.With <RemoteWatcher.Rewatch>(rew => _remoteWatcher.Tell(new RemoteWatcher.RewatchRemote(rew.Watchee, rew.Watcher)))
.With <Watch>(m => _remoteWatcher.Tell(new RemoteWatcher.WatchRemote(m.Watchee, m.Watcher)))
.With <Unwatch>(m => _remoteWatcher.Tell(new RemoteWatcher.UnwatchRemote(m.Watchee, m.Watcher)));
}
private void SendSystemMessage(ISystemMessage systemMessage)
{
try
{
Self.Tell(systemMessage);
}
catch (Exception e)
{
_systemImpl.EventStream.Publish(new Error(e, _self.Parent.ToString(), ActorType, "Swallowing exception during message send"));
}
}
/// <summary>
/// TBD
/// </summary>
/// <remarks>➡➡➡ NEVER SEND THE SAME SYSTEM MESSAGE OBJECT TO TWO ACTORS ⬅⬅⬅</remarks>
/// <param name="systemMessage">TBD</param>
public void SendSystemMessage(ISystemMessage systemMessage)
{
try
{
Dispatcher.SystemDispatch(this, (SystemMessage)systemMessage);
}
catch (Exception e)
{
_systemImpl.EventStream.Publish(new Error(e, _self.Parent.ToString(), ActorType, "Swallowing exception during message send"));
}
}
public LoginServerClient(ISessionRecivedHandler sessionRecivedHandler,
ISystemMessage systemMessage,
ILogger logger, IUdpClient udpClient,
ISoeActionFactory soeActionFactory)
{
_soeActionFactory = soeActionFactory;
_sessionRecivedHandler = sessionRecivedHandler;
_systemMessage = systemMessage;
_logger = logger;
_udpClient = udpClient;
_eventHandler.UdpPacketsRecived += TryHandleInncommingPacket;
}
public void SendSystemMessage(ISystemMessage message, IActorRef sender)
{
var d = message as DeathWatchNotification;
if (message is Terminate)
{
Stop();
}
else if (d != null)
{
this.Tell(new Terminated(d.Actor, d.ExistenceConfirmed, d.AddressTerminated));
}
}
public override void SendSystemMessage(ISystemMessage message)
{
if (message is DeathWatchNotification)
{
var deathWatchNotification = message as DeathWatchNotification;
var child = deathWatchNotification.Actor as ActorRefWithCell;
if (child != null)
{
if (child.IsLocal)
{
_terminating.Locked(() =>
{
var name = child.Path.Elements.Drop(1).Join("/");
RemoveChild(name, child);
var parent = child.Parent;
if (RemoveChildParentNeedsUnwatch(parent, child))
{
parent.SendSystemMessage(new Unwatch(parent, this));
}
TerminationHookDoneWhenNoChildren();
});
}
}
else
{
var parent = deathWatchNotification.Actor;
var parentWithScope = parent as IActorRefScope;
if (parentWithScope != null && !parentWithScope.IsLocal)
{
_terminating.Locked(() =>
{
IImmutableSet <IActorRef> children;
if (_parent2Children.TryRemove(parent, out children))
{
foreach (var c in children)
{
_system.Stop(c);
var name = c.Path.Elements.Drop(1).Join("/");
RemoveChild(name, c);
}
TerminationHookDoneWhenNoChildren();
}
});
}
}
}
else
{
base.SendSystemMessage(message);
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
public void SendSystemMessage(ISystemMessage message)
{
lock (_lock)
{
var cell = _self.Underlying;
if (CellIsReady(cell))
{
cell.SendSystemMessage(message);
}
else
{
_sysMsgQueue = _sysMsgQueue + (SystemMessage)message;
Mailbox.DebugPrint("{0} temp queueing system message {1}", Self, message);
}
}
}
/// <summary>
/// Sends the system message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendSystemMessage(ISystemMessage message)
{
try
{
//send to remote, unless watch message is intercepted by the remoteWatcher
if (message is Watch watch && IsWatchIntercepted(watch.Watchee, watch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.WatchRemote(watch.Watchee, watch.Watcher));
}
else
{
if (message is Unwatch unwatch && IsWatchIntercepted(unwatch.Watchee, unwatch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.UnwatchRemote(unwatch.Watchee,
unwatch.Watcher));
}
public override void SendSystemMessage(ISystemMessage message)
{
switch (message)
{
case Watch watch:
AddWatcher(watch.Watchee, watch.Watcher);
break;
case Unwatch unwatch:
RemoveWatcher(unwatch.Watchee, unwatch.Watcher);
break;
case DeathWatchNotification deathWatch:
this.Tell(new Terminated(deathWatch.Actor, existenceConfirmed: true, addressTerminated: false), deathWatch.Actor);
break;
}
}
//TODO: isn't SendSystemMessage supposed to be a part of ActorRef? Why isn't it overridable?
private void SendSystemMessage(ISystemMessage message)
{
if (message is Terminate)
{
Stop();
}
else if (message is DeathWatchNotification)
{
var dw = message as DeathWatchNotification;
Tell(new Terminated(dw.Actor, dw.ExistenceConfirmed, dw.AddressTerminated), this);
}
else if (message is Watch)
{
var watch = message as Watch;
if (watch.Watchee == this)
{
if (!AddWatcher(watch.Watcher))
{
// ➡➡➡ NEVER SEND THE SAME SYSTEM MESSAGE OBJECT TO TWO ACTORS ⬅⬅⬅
watch.Watcher.Tell(new DeathWatchNotification(watch.Watchee, existenceConfirmed: true,
addressTerminated: false));
}
else
{
//TODO: find a way to get access to logger?
Console.WriteLine("BUG: illegal Watch({0},{1}) for {2}", watch.Watchee, watch.Watcher, this);
}
}
}
else if (message is Unwatch)
{
var unwatch = message as Unwatch;
if (unwatch.Watchee == this && unwatch.Watcher != this)
{
RemoveWatcher(unwatch.Watcher);
}
else
{
Console.WriteLine("BUG: illegal Unwatch({0},{1}) for {2}", unwatch.Watchee, unwatch.Watcher, this);
}
}
else
{
}
}
public object ProcessRequest(ISystemMessage request)
{
var module = this._moduleManager.GetAppModule(request.SourceModule);
if (module == null)
{
return(null);
}
switch (request.Type)
{
case SystemMessageType.RenderContent:
this._content.ActivateItem(new ModuleContentViewModel
{
Title = request.Title,
ModuleName = module.Name,
ModuleIcon = module.IconContent,
ModuleContent = request.Body
});
return(null);
default:
return(null);
}
}
private void SendSystemMessage(ISystemMessage message)
{
Mailbox.DebugPrint("EmptyLocalActorRef {0} having enqueued {1}", Path, message);
SpecialHandle(message, _provider.DeadLetters);
}
/// <remarks>➡➡➡ NEVER SEND THE SAME SYSTEM MESSAGE OBJECT TO TWO ACTORS ⬅⬅⬅</remarks>
public void SendSystemMessage(ISystemMessage systemMessage)
{
try
{
Dispatcher.SystemDispatch(this, (SystemMessage)systemMessage);
}
catch (Exception e)
{
_systemImpl.EventStream.Publish(new Error(e, _self.Parent.ToString(), ActorType, "Swallowing exception during message send"));
}
}
/// <summary>
/// Sends the system message.
/// </summary>
/// <param name="message">The message.</param>
public override void SendSystemMessage(ISystemMessage message)
{
try
{
//send to remote, unless watch message is intercepted by the remoteWatcher
var watch = message as Watch;
if (watch != null && IsWatchIntercepted(watch.Watchee, watch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.WatchRemote(watch.Watchee, watch.Watcher));
}
else
{
var unwatch = message as Unwatch;
if (unwatch != null && IsWatchIntercepted(unwatch.Watchee, unwatch.Watcher))
{
RemoteProvider.RemoteWatcher.Tell(new RemoteWatcher.UnwatchRemote(unwatch.Watchee,
unwatch.Watcher));
}
else
{
Remote.Send(message, null, this);
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public override void SendSystemMessage(ISystemMessage message)
{
_cell.SendSystemMessage(message);
}
public void SendSystemMessage(ISystemMessage message)
{
ActorRef.SendSystemMessage(message);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
public override void SendSystemMessage(ISystemMessage message)
{
Underlying.SendSystemMessage(message);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
/// <param name="sender">TBD</param>
public void SendSystemMessage(ISystemMessage message, IActorRef sender)
{
_internalRef.SendSystemMessage(message);
}
public SessionRecivedHandler(ISystemMessage systemMessage)
{
_systemMessage = systemMessage;
}
internal static string GetSystemMessageContent(ISystemMessage message, IGuild guild)
=> message.Type switch
{
/// <summary>
/// Sends the system message.
/// </summary>
/// <param name="message">The message.</param>
private void SendSystemMessage(ISystemMessage message)
{
Remote.Send(message, null, this);
Remote.Provider.AfterSendSystemMessage(message);
}
public override void SendSystemMessage(ISystemMessage message)
{
if (message is DeathWatchNotification)
{
var deathWatchNotification = message as DeathWatchNotification;
var child = deathWatchNotification.Actor as ActorRefWithCell;
if (child != null)
{
if (child.IsLocal)
{
_terminating.Locked(() =>
{
var name = child.Path.Elements.Drop(1).Join("/");
RemoveChild(name, child);
var parent = child.Parent;
if (RemoveChildParentNeedsUnwatch(parent, child))
{
parent.SendSystemMessage(new Unwatch(parent, this));
}
TerminationHookDoneWhenNoChildren();
});
}
}
else
{
var parent = deathWatchNotification.Actor;
var parentWithScope = parent as IActorRefScope;
if (parentWithScope != null && !parentWithScope.IsLocal)
{
_terminating.Locked(() =>
{
IImmutableSet<IActorRef> children;
if (_parent2Children.TryRemove(parent, out children))
{
foreach (var c in children)
{
_system.Stop(c);
var name = c.Path.Elements.Drop(1).Join("/");
RemoveChild(name, c);
}
TerminationHookDoneWhenNoChildren();
}
});
}
}
}
else
{
base.SendSystemMessage(message);
}
}
/// <summary>
/// Used to invoke system messages.
/// </summary>
/// <param name="envelope">The envelope.</param>
/// <exception cref="ActorInitializationException">
/// This exception is thrown if a <see cref="Akka.Dispatch.SysMsg.Create"/> system message is included in the given <paramref name="envelope"/>.
/// </exception>
/// <exception cref="NotSupportedException">
/// This exception is thrown if an unknown message type is included in the given <paramref name="envelope"/>.
/// </exception>
internal void SystemInvoke(ISystemMessage envelope)
{
SysMsgInvokeAll(new EarliestFirstSystemMessageList((SystemMessage)envelope), CalculateState());
}
public void SendSystemMessage(ISystemMessage systemMessage)
{
try
{
// TODO: use a dispatcher or the mailbox to post a message directly
_mailbox.Post(Self, new Envelope() { Message = systemMessage, Sender = ActorRefs.NoSender});
}
catch (Exception e)
{
_systemImpl.EventStream.Publish(new Error(e, _self.Parent.ToString(), ActorType, "Swallowing exception during message send"));
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
public override void SendSystemMessage(ISystemMessage message)
{
Mailbox.DebugPrint("EmptyLocalActorRef {0} having enqueued {1}", Path, message);
SpecialHandle(message, _provider.DeadLetters);
}
//全て手動. 汚い.
public static string Translate(ISystemMessage systemMessage)
{
var type = systemMessage.GetType();
var translator = LanguageManager.Instance.Translator;
if (type == typeof(NotYourTurnMessage))
{
return(translator.Translate(TranslatableKeys.NotYourTurnMessage).Text);
}
else if (type == typeof(NotYourPieceMessage))
{
return(translator.Translate(TranslatableKeys.NotYourPieceMessage).Text);
}
else if (type == typeof(PieceMovementMessage))
{
//Player = player;
//Piece = piece;
//StartPosition = startPosition;
//EndPosition = endPosition;
var message = (PieceMovementMessage)systemMessage;
return(translator.Translate(TranslatableKeys.PieceMovementMessage).Text
.Replace("#PIECE_NAME#", PieceNameTranslator.Translate(message.Piece.Name, translator))
.Replace("#START_POSITION#", message.StartPosition.ToString())
.Replace("#END_POSITION#", message.EndPosition.ToString()));
}
else if (type == typeof(PieceViaMovementMessage))
{
//Player = player;
//Piece = piece;
//StartPosition = startPosition;
//ViaPosition = viaPosition;
//EndPosition = endPosition;
var message = (PieceViaMovementMessage)systemMessage;
return(translator.Translate(TranslatableKeys.PieceViaMovementMessage).Text
.Replace("#PIECE_NAME#", PieceNameTranslator.Translate(message.Piece.Name, translator))
.Replace("#START_POSITION#", message.StartPosition.ToString())
.Replace("#VIA_POSITION#", message.ViaPosition.ToString())
.Replace("#END_POSITION#", message.EndPosition.ToString()));
}
else if (type == typeof(PieceMovementFailureMessage))
{
return(translator.Translate(TranslatableKeys.PieceMovementFailureMessage).Text);
}
else if (type == typeof(NoPieceViaPointMessage))
{
return(translator.Translate(TranslatableKeys.NoPieceViaPointMessage).Text);
}
else if (type == typeof(NoPieceSelectedMessage))
{
return(translator.Translate(TranslatableKeys.NoPieceSelectedMessage).Text);
}
else if (type == typeof(SetPieceMessage))
{
//Player = player;
//Piece = piece;
//SetPosition = setPosition;
var message = (SetPieceMessage)systemMessage;
return(translator.Translate(TranslatableKeys.SetPieceMessage).Text
.Replace("#PIECE_NAME#", PieceNameTranslator.Translate(message.Piece.Name, translator))
.Replace("#POSITION#", message.SetPosition.ToString()));
}
else if (type == typeof(SetPieceFailureMessage))
{
return(translator.Translate(TranslatableKeys.SetPieceFailureMessage).Text);
}
return(string.Empty);
}
public void SendSystemMessage(ISystemMessage message, IActorRef sender)
{
SendSystemMessage(message);
}
/// <inheritdoc cref="InternalActorRefBase"/>
public override void SendSystemMessage(ISystemMessage message)
{
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
public void SendSystemMessage(ISystemMessage message)
{
_internalRef.SendSystemMessage(message);
}
public void SendSystemMessage(ISystemMessage message, IActorRef sender)
{
((IInternalActorRef)TestActor).SendSystemMessage(message, sender);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
public override void SendSystemMessage(ISystemMessage message)
{
base.SendSystemMessage(message);
}
public void SendSystemMessage(ISystemMessage message)
{
SendSystemMessage(message, ActorRefs.Nobody);
}
/// <inheritdoc cref="IInternalActorRef"/> public abstract void SendSystemMessage(ISystemMessage message);
/// <summary>
/// Sends the system message.
/// </summary>
/// <param name="message">The message.</param>
private void SendSystemMessage(ISystemMessage message)
{
Remote.Send(message, null, this);
Remote.Provider.AfterSendSystemMessage(message);
}
private void SendSystemMessage(ISystemMessage systemMessage)
{
try
{
Self.Tell(systemMessage);
}
catch (Exception e)
{
_systemImpl.EventStream.Publish(new Error(e, _self.Parent.ToString(), ActorType, "Swallowing exception during message send"));
}
}
public void SendSystemMessage(ISystemMessage message)
{
lock (_lock)
{
var cell = _self.Underlying;
if (CellIsReady(cell))
{
cell.SendSystemMessage(message);
}
else
{
_sysMsgQueue = _sysMsgQueue + (SystemMessage)message;
Mailbox.DebugPrint("{0} temp queueing system message {1}", Self, message);
}
}
}
/// <summary>
/// Sends a system message to the test probe
/// </summary>
/// <param name="message">The message to send</param>
public void SendSystemMessage(ISystemMessage message)
{
((IInternalActorRef)TestActor).SendSystemMessage(message);
}
public override void SendSystemMessage(ISystemMessage message)
{
Underlying.SendSystemMessage(message);
}
/// <inheritdoc/>
public override void SendSystemMessage(ISystemMessage message)
{
_cell.SendSystemMessage(message);
}
/// <summary>
/// Used to invoke system messages.
/// </summary>
/// <param name="envelope">The envelope.</param>
/// <exception cref="ActorInitializationException">
/// This exception is thrown if a <see cref="Akka.Dispatch.SysMsg.Create"/> system message is included in the given <paramref name="envelope"/>.
/// </exception>
/// <exception cref="NotSupportedException">
/// This exception is thrown if an unknown message type is included in the given <paramref name="envelope"/>.
/// </exception>
internal void SystemInvoke(ISystemMessage envelope)
{
SysMsgInvokeAll(new EarliestFirstSystemMessageList((SystemMessage)envelope), CalculateState());
}
