protected override void OnReceive(object message)
{
var text = Console.ReadLine();
switch (text)
{
case "quit":
_consoleUi.Tell("terminate");
return;
default:
// Tell something!
_commandHandler.Tell(new InputCommand(text));
// Ask something!
ColoredConsole.WriteLineYellow("Awaiting for the command to complete");
var completedTask = _commandHandler.Ask <InputCommandResponse>(new InputCommandRequest(text));
completedTask.Wait(); // blocking operation: wait for completion and a specific reply
ColoredConsole.WriteLineYellow($"Response: {completedTask.Result.Data}");
ColoredConsole.WriteLineYellow("The command has been completed");
break;
}
// send a message to outself stating we are ready to read the next command
Self.Tell("readnext");
// we have no unhandled message here, every message will activare the read cycle again.
}
private bool Handle(RoutedCommandEnvelope command)
{
// create a command handing actor instance if needed
// forward the command to them
var childActorName = GenerateActorName(command);
var child = Context.Child(childActorName);
if (child == ActorRefs.Nobody)
{
switch (command.RouteTo.Type)
{
case ActorTypes.CommandHandler1:
child = Context.ActorOf(Props.Create <CommandHandler1>(_writer), childActorName);
break;
case ActorTypes.CommandHandler2:
child = Context.ActorOf(Props.Create <CommandHandler2>(_writer), childActorName);
break;
case ActorTypes.Room:
child = Context.ActorOf(Context.DI().Props <RoomActor>(), childActorName);
break;
}
}
// check for stop, poisonpill, kill, gracefulstop commands..
// It's responsibility of this Actor manage its children
switch (command.Command)
{
case StopCommand cmd:
Context.Stop(child);
return(true);
case PoisonPill cmd:
child.Tell(PoisonPill.Instance);
return(true);
case KillCommand cmd:
child.Tell(Kill.Instance);
return(true);
case GracefulStopCommand cmd:
var gracefulStop = child.GracefulStop(TimeSpan.FromSeconds(5));
gracefulStop.Wait();
if (gracefulStop.Result)
{
ColoredConsole.WriteLineGreen("GracefulStop completed");
}
else
{
ColoredConsole.WriteLineYellow("GracefulStop failed");
}
return(true);
}
// child.Tell(command.Command);
child.Forward(command.Command);
return(true);
}
private bool Handle(Shared.Messages.Command command)
{
// create a command handling actor instance if needed and then
// forward the command
var childActorId = GetHashMapping(command);
var child = Context.Child(childActorId);
if (child == ActorRefs.Nobody)
{
child = Context.ActorOf(Props.Create <CommandHandlerWorkerActor>(_writer), childActorId);
}
// check for stop, poisonpill, kill, gracefulstop commands..
// It's responsibility of this Actor to manage its children
switch (command)
{
case StopCommand cmd:
Context.Stop(child);
return(true);
case PoisonPillCommand cmd:
child.Tell(PoisonPill.Instance);
return(true);
case KillCommand cmd:
child.Tell(Kill.Instance);
return(true);
case GracefulStopCommand cmd:
try
{
var gracefulStop = child.GracefulStop(TimeSpan.FromSeconds(5));
gracefulStop.Wait();
ColoredConsole.WriteLineGreen("GracefulStop completed");
}
catch (AggregateException ex)
{
// the GracefulStop can fail if it cannot complete within the specified TimeSpan.
// The Task will be cancelled.
ColoredConsole.WriteLineYellow($"GracefulStop failed, exception: {ex}");
}
return(true);
}
// child.Tell(command);
child.Forward(command);
return(true);
}
private void Paused()
{
Receive <ResumeCommandHandlerCommand>(message =>
{
_writer.Tell("Resuming operations...");
Become(Running);
// UnbecomeStacked();
// Unstash all the messages
Stash.UnstashAll();
});
// ReceiveAny must always be the last one!
ReceiveAny((message) =>
{
ColoredConsole.WriteLineYellow($"Out of service: {message}");
// Stash the messages for later processing
Stash.Stash();
});
}
protected override void OnReceive(object message)
{
var text = Console.ReadLine();
// Parse the Command (not production code! :D)
// First check the stop/kill commands directed to the router
switch (text)
{
case QuitCommand:
_consoleUi.Tell("terminate");
return;
case StopCommand:
// Send a System Stop message to the specified actor (the message will have priority over others already in the mailbox).
// Actor receives the Stop message and suspends the actor’s Mailbox (other messages will go to DeadLetters).
// Actor tells all its children to Stop. Stop messages propagate down the hierarchy below the actor.
// Actor waits for all children to stop.
// Actor calls PostStop lifecycle hook method for resource cleanup.
// Actor shuts down.
Context.Stop(_commandHandler);
ReadNext();
return;
case PoisonPillCommand:
// Use a PoisonPill message if you want the actor to process its mailbox before shutting down.
// PoisonPill is a message that will be placed in the mailbox.
// When the Actor process the message the above mentioned stop sequence will be initiated.
_commandHandler.Tell(PoisonPill.Instance);
ReadNext();
return;
case KillCommand:
// Use a Kill message if you want it to show in your logs that the actor was killed.
// Send a System Kill message to the specified actor.
// The actor throws an ActorKilledException (The actor’s supervisor logs this message).
// This suspends the actor mailbox from processing further user messages.
// The actor’s supervisor handles the ActorKilledException and issues a Stop directive.
// The actor will stop following the above mentioned stop sequence.
_commandHandler.Tell(Kill.Instance);
ReadNext();
return;
case GracefulStopCommand:
// If you want confirmation that the actor was stopped within a specified Timespan.
// It will send a PoisonPill message and 'start a timer to check if the actor stops within the specified amount of time'.
// It will return a Task<bool> you can wait on to know if the Actor was stopped.
// The Task can be cancelled if the Actor does not stop with the specified TimeSpan.
try
{
var gracefulStop = _commandHandler.GracefulStop(TimeSpan.FromSeconds(5));
gracefulStop.Wait();
ColoredConsole.WriteLineGreen("GracefulStop completed");
}
catch (AggregateException ex)
{
// the GracefulStop can fail if it cannot complete within the specified TimeSpan.
// The Task will be cancelled.
ColoredConsole.WriteLineYellow($"GracefulStop failed, exception: {ex}");
}
ReadNext();
return;
}
// Try to parse the User Commands: 'UserId command'
var parsedText = text.Split(' ');
if (parsedText.Length == 2)
{
Command cmd;
switch (parsedText[1])
{
case EscalateExceptionCommand:
cmd = new EscalateExceptionCommand();
break;
case RestartExceptionCommand:
cmd = new RestartExceptionCommand();
break;
case ResumeExceptionCommand:
cmd = new ResumeExceptionCommand();
break;
case StopExceptionCommand:
cmd = new StopExceptionCommand();
break;
case PauseCommandHandlerCommand:
cmd = new PauseCommandHandlerCommand();
break;
case ResumeCommandHandlerCommand:
cmd = new ResumeCommandHandlerCommand();
break;
default:
// Tell something!
cmd = new InputCommand(parsedText[1]);
/*
* // Ask something!
* ColoredConsole.WriteLineYellow("Awaiting for the command to complete");
* var completedTask = _commandHandler.Ask<InputCommandResponse>(new InputCommandRequest(parsedText[1]));
* completedTask.Wait(); // blocking operation: wait for completion and a specific reply
* ColoredConsole.WriteLineYellow($"Response: {completedTask.Result.Data}");
* ColoredConsole.WriteLineYellow("The command has been completed");
*/
break;
}
cmd.Context.UserId = parsedText[0];
_commandHandler.Tell(cmd);
}
else
{
ReportUnsupportedCommand(text);
}
ReadNext();
// we have no unhandled message here, every message will activare the read cycle again.
}
private void ReportUnsupportedCommand(string text)
{
ColoredConsole.WriteLineYellow("Unsuported command: " + text);
}
protected override void OnReceive(object message)
{
// actually every message activates the reader
var text = System.Console.ReadLine();
switch (text)
{
case QuitCommand:
_consoleUi.Tell("terminate");
return;
case StopCommand:
// Actor receives the Stop message and suspends the actor’s Mailbox (other messages will go to DeadLetters).
// Actor tells all its children to Stop. Stop messages propagate down the hierarchy below the actor.
// Actor waits for all children to stop.
// Actor calls PostStop lifecycle hook method for resource cleanup.
// Actor shuts down.
Context.Stop(_commandHandler);
break;
case PoisonPillCommand:
// Use a PoisonPill message if you want the actor to process its mailbox before shutting down.
// PoisonPill is a message that will be placed in the mailbox.
// When the Actor process the message the above mentioned stop sequence will be initiated.
_commandHandler.Tell(PoisonPill.Instance);
break;
case KillCommand:
// Use a Kill message if you want it to show in your logs that the actor was killed.
// The actor throws an ActorKilledException. The actor’s supervisor logs this message.
// This suspends the actor mailbox from processing further user messages.
// The actor’s supervisor handles the ActorKilledException and issues a Stop directive.
// The actor will stop following the above mentioned stop sequence.
_commandHandler.Tell(Kill.Instance);
break;
case GracefulStopCommand:
// If you want confirmation that the actor was stopped within a specified Timespan.
// It will return a Task<bool> you can check to know if the Actor was stopped.
var gracefulStop = _commandHandler.GracefulStop(TimeSpan.FromSeconds(5));
gracefulStop.Wait();
if (gracefulStop.Result)
{
ColoredConsole.WriteLineGreen("GracefulStop completed");
}
else
{
ColoredConsole.WriteLineYellow("GracefulStop failed");
}
break;
case EscalateExceptionCommand:
_commandHandler.Tell(new EscalateExceptionCommand());
break;
case RestartExceptionCommand:
_commandHandler.Tell(new RestartExceptionCommand());
break;
case ResumeExceptionCommand:
_commandHandler.Tell(new ResumeExceptionCommand());
break;
case StopExceptionCommand:
_commandHandler.Tell(new StopExceptionCommand());
break;
case DumpStatusCommand:
_commandHandler.Tell(new DumpStatusCommand());
break;
default:
_commandHandler.Tell(text);
break;
}
// send a message to outself stating we are ready to read the next command
Self.Tell("readnext");
// we have no unhandled message here, every message will activare the read cycle again.
}