bool Handle(RestartExceptionCommand message)
 {
     throw new RestartException();
 }
예제 #2
0
        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 bool Handle(RestartExceptionCommand c)
 {
     throw new RestartException();
 }