akka.actor.SupervisorStrategy Java Examples

@Override
public SupervisorStrategy create() {
	return new OneForOneStrategy(
		false,
		new PFBuilder<Throwable, SupervisorStrategy.Directive>()
			.match(
				Exception.class,
				(Exception e) -> {
					if (e instanceof ActorKilledException) {
						LOG.debug("Actor was killed. Stopping it now.", e);
					} else {
						LOG.error("Actor failed with exception. Stopping it now.", e);
					}
					return SupervisorStrategy.Stop$.MODULE$;
				})
			.build());
}
 

/**
 * Start a cluster singleton actor.
 *
 * @param system the actor system.
 * @param actorRefFactory where the cluster singleton should be created.
 * @param role role of this cluster member.
 * @param actorName name of the singleton actor.
 * @param props Props of the singleton actor.
 * @param supervisorStrategy the {@link SupervisorStrategy} for the singleton actor.
 * @return reference of the singleton actor.
 */
public static ActorRef startSingleton(final ActorSystem system,
        final ActorRefFactory actorRefFactory,
        final String role,
        final String actorName,
        final Props props,
        final SupervisorStrategy supervisorStrategy) {

    final ClusterSingletonManagerSettings settings =
            ClusterSingletonManagerSettings.create(system).withRole(role);

    final Props supervisorProps = ClusterSingletonSupervisorActor.props(props, supervisorStrategy);
    final Props singletonManagerProps =
            ClusterSingletonManager.props(supervisorProps, PoisonPill.getInstance(), settings);
    return actorRefFactory.actorOf(singletonManagerProps, actorName);
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return new OneForOneStrategy(true, DeciderBuilder
            .match(NullPointerException.class, e -> {
                log.error(e, "NullPointer in child actor - restarting it...", e.getMessage());
                log.info("Restarting child...");
                return SupervisorStrategy.restart();
            })
            .match(ActorKilledException.class, e -> {
                log.error(e.getCause(), "ActorKilledException in child actor - stopping it...");
                return SupervisorStrategy.stop();
            })
            .matchAny(e -> SupervisorStrategy.escalate())
            .build());
}
 

@Override
public SupervisorStrategy create() {
	return new OneForOneStrategy(
		false,
		new PFBuilder<Throwable, SupervisorStrategy.Directive>()
			.match(
				Exception.class,
				(Exception e) -> {
					if (e instanceof ActorKilledException) {
						LOG.debug("Actor was killed. Stopping it now.", e);
					} else {
						LOG.error("Actor failed with exception. Stopping it now.", e);
					}
					return SupervisorStrategy.Stop$.MODULE$;
				})
			.build());
}
 

@Override
public SupervisorStrategy create() {
	return new OneForOneStrategy(
		false,
		new PFBuilder<Throwable, SupervisorStrategy.Directive>()
			.matchAny(
				(ignored) -> SupervisorStrategy.escalate())
			.build());
}
 

@Override
public Directive apply(Throwable t) {
  logger.error(t, "Unknown failure");
  if (t instanceof RuntimeException) {
    return SupervisorStrategy.restart();
  } else {
    return SupervisorStrategy.stop();
  }
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
  return new OneForOneStrategy(-1, Duration.Inf(), throwable -> {
    logger.error(throwable, "Unknown session error");
    if (throwable instanceof Error) {
      return OneForOneStrategy.escalate();
    } else {
      return OneForOneStrategy.resume();
    }
  });
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return new AllForOneStrategy(
            DeciderBuilder.matchAny(error -> {
                final Duration restartDelay = config.getRestartDelay();
                log.error(error, "Child <{}> crashed. Restarting all children after <{}>",
                        getSender(), restartDelay);
                getTimers().startSingleTimer(Control.RESTART, Control.RESTART, restartDelay);
                onChildFailure();
                return SupervisorStrategy.stop();
            }).build());
}
 

@Override
protected PartialFunction<Throwable, SupervisorStrategy.Directive> getSupervisionDecider() {
    return DeciderBuilder.match(JMSRuntimeException.class, e -> {
        log.warning("JMSRuntimeException '{}' occurred.", e.getMessage());
        return restartChild();
    }).match(NamingException.class, e -> {
        log.warning("NamingException '{}' occurred.", e.getMessage());
        return restartChild();
    }).build().orElse(super.getSupervisionDecider());
}
 

@Override
public PartialFunction<Throwable, Directive> decider() {
	return DeciderBuilder.match(
		Exception.class, e -> SupervisorStrategy.stop()
	).build();
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
  return strategy;
}
 

@Test
public void checkForActivityOfNonexistentPolicy() {
    new TestKit(actorSystem) {
        {
            // GIVEN: a PolicyPersistenceActor is created in a parent that forwards all messages to us
            final PolicyId policyId = PolicyId.of("test.ns", "nonexistent.policy");
            final Props persistentActorProps =
                    PolicyPersistenceActor.props(policyId, new PolicyMongoSnapshotAdapter(), pubSubMediator);

            final TestProbe errorsProbe = TestProbe.apply(actorSystem);

            final Props parentProps = Props.create(Actor.class, () -> new AbstractActor() {

                @Override
                public void preStart() {
                    getContext().actorOf(persistentActorProps);
                }

                @Override
                public SupervisorStrategy supervisorStrategy() {
                    return new OneForOneStrategy(true,
                            DeciderBuilder.matchAny(throwable -> {
                                errorsProbe.ref().tell(throwable, getSelf());
                                return SupervisorStrategy.restart();
                            }).build());
                }

                @Override
                public Receive createReceive() {
                    return ReceiveBuilder.create()
                            .matchAny(message -> {
                                if (getTestActor().equals(getSender())) {
                                    getContext().actorSelection(getSelf().path().child("*"))
                                            .forward(message, getContext());
                                } else {
                                    getTestActor().forward(message, getContext());
                                }
                            })
                            .build();
                }
            });

            // WHEN: CheckForActivity is sent to a persistence actor of nonexistent policy after startup
            final ActorRef underTest = actorSystem.actorOf(parentProps);

            final Object checkForActivity = AbstractShardedPersistenceActor.checkForActivity(1L);
            underTest.tell(checkForActivity, getRef());
            underTest.tell(checkForActivity, getRef());
            underTest.tell(checkForActivity, getRef());

            // THEN: persistence actor requests shutdown
            expectMsg(PolicySupervisorActor.Control.PASSIVATE);

            // THEN: persistence actor should not throw anything.
            errorsProbe.expectNoMessage(scala.concurrent.duration.Duration.create(3, TimeUnit.SECONDS));
        }
    };
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return SupervisorStrategy.stoppingStrategy();
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return SUPERVISOR_STRATEGY;
}
 

public static OneForOneStrategy createStrategy(final LoggingAdapter log) {
    return new OneForOneStrategy(true, DeciderBuilder
            .match(NullPointerException.class, e -> {
                log.error(e, "NullPointer in child actor: {}", e.getMessage());
                log.info(RESTARTING_CHILD_MSG);
                return SupervisorStrategy.restart();
            }).match(IllegalArgumentException.class, e -> {
                log.warning("Illegal Argument in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(IndexOutOfBoundsException.class, e -> {
                log.warning("IndexOutOfBounds in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(IllegalStateException.class, e -> {
                log.warning("Illegal State in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(NoSuchElementException.class, e -> {
                log.warning("NoSuchElement in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(AskTimeoutException.class, e -> {
                log.warning("AskTimeoutException in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(ConnectException.class, e -> {
                log.warning("ConnectException in child actor: {}", e.getMessage());
                log.info(RESTARTING_CHILD_MSG);
                return SupervisorStrategy.restart();
            }).match(InvalidActorNameException.class, e -> {
                log.warning("InvalidActorNameException in child actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(ActorKilledException.class, e -> {
                log.error(e, "ActorKilledException in child actor: {}", e.message());
                log.info(RESTARTING_CHILD_MSG);
                return SupervisorStrategy.restart();
            }).match(DittoRuntimeException.class, e -> {
                log.error(e,
                        "DittoRuntimeException '{}' should not be escalated to RootActor. Simply resuming Actor.",
                        e.getErrorCode());
                return SupervisorStrategy.resume();
            }).match(Throwable.class, e -> {
                log.error(e, "Escalating above root actor!");
                return SupervisorStrategy.escalate();
            }).matchAny(e -> {
                log.error("Unknown message:'{}'! Escalating above root actor!", e);
                return SupervisorStrategy.escalate();
            }).build());
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return supervisorStrategy;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return strategy;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
	LOG.debug("Custom supervisorStrategy is used for SetupDocumentTypeWorkerActor!");
	return strategy;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return supervisorStrategy;
}
 

private SupervisorStrategy.Directive restartChild() {
    log.info("Restarting child ...");
    return SupervisorStrategy.restart();
}
 

private OneForOneStrategy buildDefaultSupervisorStrategy() {
    return new OneForOneStrategy(true, DeciderBuilder
            .match(NullPointerException.class, e -> {
                log.error(e, "NullPointer in singleton actor: {}", e.getMessage());
                return restartChild();
            }).match(IllegalArgumentException.class, e -> {
                log.warning("Illegal Argument in singleton actor: {}", e.getMessage());

                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                e.printStackTrace(pw);

                log.warning("Illegal Argument in singleton actor: {}", sw.toString());
                return SupervisorStrategy.resume();
            }).match(IllegalStateException.class, e -> {
                log.warning("Illegal State in singleton actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(IndexOutOfBoundsException.class, e -> {
                log.warning("IndexOutOfBounds in singleton actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(NoSuchElementException.class, e -> {
                log.warning("NoSuchElement in singleton actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(AskTimeoutException.class, e -> {
                log.warning("AskTimeoutException in singleton actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(ConnectException.class, e -> {
                log.warning("ConnectException in singleton actor: {}", e.getMessage());
                return restartChild();
            }).match(InvalidActorNameException.class, e -> {
                log.warning("InvalidActorNameException in singleton actor: {}", e.getMessage());
                return SupervisorStrategy.resume();
            }).match(ActorKilledException.class, e -> {
                log.error(e, "ActorKilledException in singleton actor: {}", e.message());
                return restartChild();
            }).match(DittoRuntimeException.class, e -> {
                log.error(e,
                        "DittoRuntimeException '{}' should not be escalated to SupervisorActor. Simply resuming Actor.",
                        e.getErrorCode());
                return SupervisorStrategy.resume();
            }).match(UnsupportedOperationException.class, e -> {
                log.error(e, "UnsupportedOperationException in singleton actor: {}",
                        e.getMessage());
                terminateActorSystem();
                return SupervisorStrategy.stop(); // only stopping as ActorSystem is terminated anyways
            }).match(Throwable.class, e -> {
                log.error(e, "Escalating above root actor!");
                terminateActorSystem();
                return SupervisorStrategy.stop(); // only stopping as ActorSystem is terminated anyways
            }).matchAny(e -> {
                log.error("Unknown message:'{}'! Escalating above root actor!", e);
                terminateActorSystem();
                return SupervisorStrategy.stop(); // only stopping as ActorSystem is terminated anyways
            }).build());
}
 

@SuppressWarnings("unused")
ClusterSingletonSupervisorActor(final Props childProps, final SupervisorStrategy supervisorStrategy) {
    this.supervisorStrategy = supervisorStrategy;
    this.child = getContext().actorOf(childProps, "supervised-child");
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
    return strategy;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
	return Master.strategy;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
  return DEFAULT_STRATEGY;
}
 

@Override
public SupervisorStrategy supervisorStrategy() {
	return strategy;
}
 

/**
 * @return supervisorStrategy the actor supervisor strategy
 */
@Override
public SupervisorStrategy supervisorStrategy() {
	return strategy;
}
 

/**
 * Start a cluster singleton actor.
 *
 * @param context context of the actor whose child the cluster singleton manager shall be.
 * @param role role of this cluster member.
 * @param actorName name of the singleton actor.
 * @param props Props of the singleton actor.
 * @param supervisorStrategy the {@link SupervisorStrategy} for the singleton actor.
 * @return reference of the singleton actor.
 */
public static ActorRef startSingleton(final ActorContext context,
        final String role,
        final String actorName,
        final Props props,
        final SupervisorStrategy supervisorStrategy) {

    return startSingleton(context.system(), context, role, actorName, props, supervisorStrategy);
}
 

/**
 * Creates Akka configuration object Props for this Actor.
 *
 * @param childProps the Props of the child to create (the actual singleton).
 * @param supervisorStrategy the {@link SupervisorStrategy} to apply.
 * @return the Akka configuration Props object.
 */
public static Props props(final Props childProps, final SupervisorStrategy supervisorStrategy) {

    return Props.create(ClusterSingletonSupervisorActor.class, childProps, supervisorStrategy);
}
 

/**
 * Return a preferably static supervisor strategy for this actor. By default, child actor is stopped when killed
 * or failing, triggering restart after exponential back-off.
 * Overriding method should return a static object if possible to conserve memory.
 *
 * @return The default supervisor strategy.
 */
@Override
public SupervisorStrategy supervisorStrategy() {
    return SupervisorStrategy.stoppingStrategy();
}