protected void initSupervisor(final String supervising, int nRetries, String maxDuration) { strategy = new OneForOneStrategy(nRetries == -1 ? Integer.MAX_VALUE : nRetries, ("-1".equals(maxDuration) ? Duration.Inf() : Duration.create(maxDuration)), new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { switch (supervising) { case ESCALATE: return escalate(); case RESTART: return restart(); case RESUME: return resume(); case STOP: return stop(); default: return escalate(); } } }); }
@Override public Directive apply(final Throwable t) { if (t instanceof DocumentTypeDataGenerationException) { return restart(); } else if (t instanceof DocumentGenerationException) { return restart(); } else if (t instanceof IndexDataException) { return restart(); } else if (t instanceof ActorInitializationException) { return stop(); } else if (t instanceof ActorKilledException) { return stop(); } else if (t instanceof Exception) { return restart(); } else { return escalate(); } }
private static SupervisorStrategy buildResumeOnRuntimeErrorStrategy() { return new OneForOneStrategy(-1, Duration.Inf(), new Function<Throwable, SupervisorStrategy.Directive>() { @Override public Directive apply(Throwable throwable) throws Exception { logException(throwable); if (throwable instanceof Error) { return OneForOneStrategy.escalate(); } else if (throwable instanceof RuntimeException) { return OneForOneStrategy.resume(); } else { return OneForOneStrategy.restart(); } } }); }
@Override public SupervisorStrategy supervisorStrategy() { return new OneForOneStrategy(10, Duration.create("1 minute"), (Function<Throwable, Directive>) t -> { LOG.warn("Supervisor Strategy caught unexpected exception - resuming", t); return SupervisorStrategy.resume(); }); }
@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 AllForOneStrategy(10, Duration.create(1, TimeUnit.HOURS), new Function<Throwable, Directive>() { @Override public Directive apply(Throwable param) throws Exception { if (param instanceof IllegalArgumentException) return escalate(); if (param instanceof ArithmeticException) return escalate(); if (param instanceof NullPointerException) return escalate(); else return stop(); } } ); }
/** * The supervisor strategy. * * @param notificationRetryNumber * Number of retry when a delivery failed. * @param notificationRetryDuration * How long to wait before attempting to distribute the message * again. */ private static SupervisorStrategy getSupervisorStrategy(int notificationRetryNumber, String notificationRetryDuration) { return new OneForOneStrategy(notificationRetryNumber, Duration.create(notificationRetryDuration), new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { log.error("An notification processor reported an exception, retry", t); return resume(); } }); }
/** * Creates a {@link OneForOneStrategy} using the specified parameters. * * @param numberOfRetry * a number of retry * @param withinTimeRange * the time range * @param pluginConfigurationId * the unique id of the plugin configuration */ private static SupervisorStrategy getSupervisorStrategy(int numberOfRetry, Duration withinTimeRange, Long pluginConfigurationId) { final String errorMessage = String.format("An provisioning processor of the plugin %d reported an exception, retry", pluginConfigurationId); return new OneForOneStrategy(numberOfRetry, withinTimeRange, new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { log.error(errorMessage, t); return resume(); } }); }
@Override public Directive apply(Throwable t) { if (t instanceof ArithmeticException) { return SupervisorStrategy.resume() ; } else if (t instanceof NullPointerException) { return SupervisorStrategy.stop(); } else if (t instanceof IllegalArgumentException) { return SupervisorStrategy.stop(); } else { return SupervisorStrategy.escalate(); } }
private static SupervisorStrategy buildResumeOrEscalateStrategy() { return new OneForOneStrategy(-1, Duration.Inf(), new Function<Throwable, SupervisorStrategy.Directive>() { @Override public Directive apply(Throwable throwable) throws Exception { logException(throwable); if (throwable instanceof Error) { return OneForOneStrategy.escalate(); } else { return OneForOneStrategy.resume(); } } }); }
private static SupervisorStrategy buildRestartOrEscalateStrategy() { return new OneForOneStrategy(-1, Duration.Inf(), new Function<Throwable, SupervisorStrategy.Directive>() { @Override public Directive apply(Throwable throwable) throws Exception { logException(throwable); if (throwable instanceof Error) { return OneForOneStrategy.escalate(); } else { return OneForOneStrategy.restart(); } } }); }
@Override public Directive apply(Throwable t) throws Exception { if(t instanceof ActorInitializationException) { return OneForOneStrategy.stop(); } else if(t instanceof Exception) { return OneForOneStrategy.restart(); } return OneForOneStrategy.escalate(); }
public Directive apply(Throwable t) { if (t instanceof ArithmeticException) { return resume(); } else if (t instanceof NullPointerException) { return restart(); } else if (t instanceof IllegalArgumentException) { return stop(); } else { return escalate(); } }
public Directive apply(Throwable t) { if (t instanceof CoordinatedTransactionException) { return resume(); } else if (t instanceof IllegalStateException) { return resume(); } else if (t instanceof IllegalArgumentException) { return stop(); } else { return escalate(); } }
public Directive apply(Throwable t) { if (t instanceof CoordinatedTransactionException) { return resume(); } else if (t instanceof IllegalStateException) { return stop(); } else if (t instanceof IllegalArgumentException) { return stop(); } else { return escalate(); } }
public Directive apply(Throwable t) { if (t instanceof ArithmeticException) { return resume(); } else if (t instanceof IllegalArgumentException) { return restart(); } else if (t instanceof NullPointerException) { return stop(); } else { return escalate(); } }
public Directive apply(Throwable t) { if (t instanceof IllegalArgumentException) { return stop(); } else if (t instanceof NullPointerException) { return resume(); } else return escalate(); }
public Directive apply(Throwable t) { if (t instanceof Exception) { return stop(); } return escalate(); }
private Function<Throwable, Directive> myDecider() { return new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { if ( t instanceof ActorInitializationException || t instanceof ActorKilledException || t instanceof DeathPactException ) { return SupervisorStrategy.stop(); } else if ( t instanceof Exception ) { Class<? extends Throwable> clazz = t.getClass(); ImmutableSet<Entry<Class<?>, Method>> entrySet = javactorInfoByJavactorType .get(javactor.getClass()).getSupervisorStrategyInfo().getOnExceptionMethods() .entrySet(); for (Entry<Class<?>, Method> entry : entrySet) { if (entry.getKey().isAssignableFrom(clazz)) { final Method method = entry.getValue(); try { return map((SupervisorDirective) methodInvoke( method, javactor, t)); } catch (Exception e) { throw new RuntimeException(e); } } } return SupervisorStrategy.restart(); } else { return SupervisorStrategy.escalate(); } } }; }
private Directive map(SupervisorDirective supDirective) { return JAVACTOR_DIRECTIVES_TO_AKKA.get(supDirective); }
@Override public Directive apply(Throwable t) { return OneForOneStrategy.stop(); }
@Override public Directive apply(Throwable t) throws Exception { return AllForOneStrategy.restart(); }
@Override public Directive apply(Throwable t) throws Exception { return AllForOneStrategy.escalate(); }