Verticles und nicht abgefangene Ausnahmen

Angesichts der Szenario, dass einer der verticles eine nicht abgefangene Ausnahme.

Was passiert als Nächstes?
Wenn der senkrechte Zustand aus dem system entfernt wird, gibt es einige Mechanismen ähnlich zu erlang Aufsichtsbehörden neu zu starten, die senkrechte?

Dokumentation ist nicht sehr klar über diesen Aspekt.

Update basiert auf Kommentare:
Was interessiert mich die meisten ist die situation, wenn eine Ausnahme geworfen wird, von der Verarbeitung-Handler der empfangenen Nachricht (über den bus)

Hinsichtlich

Könnten Sie besser erarbeiten wenn diese exception wird geworfen? Ist es zum Zeitpunkt der Bereitstellung? Bei message-handling-Zeit?...
Ich dachte mehr über die message-handling-Zeit, aber Ihr Punkt ist getroffen. Ich wäre auch daran interessiert bei der Bereitstellung.

InformationsquelleAutor mhstnsc | 2015-06-22

vert.x

7

Habe ich beantwortet einen Teil meiner Frage selbst (mit Hilfe eines Testprogramms)

Wenn exception geworfen wird, in einem Ereignis-handler dann die Ausnahme abgefangen wird, indem Sie vert.x und Verschlucken (ignoriert). Der event-handler mit der Bearbeitung der nächsten Nachricht.

Update: Die app kann registrieren Sie einen exception-handler und haben alle nicht erfassten Throwable geliefert, um diesen handler. Dort können Sie zusätzliche Allgemeine Verarbeitung

Update2: Verwenden Sie Vertx.exceptionHandler zum registrieren der handler
- Wie können wir das tun ?
InformationsquelleAutor mhstnsc
6

Vert.x ist alles über den gleichen Stil, asynchrone Programmierung, die vor allem hervorgehoben durch callback-Handler.

Griff der Bereitstellung Versagen Fall, müssen Sie zuerst zu gehen, den programmatischen Weg, d.h. Sie müssen zum bereitstellen von verticle programmgesteuert durch lassen Sie uns sagen, ein Bereitstellung verticle bietet eine completion handler, der aufgefüllt wird mit das Ergebnis der Implementierung ist, hier unten ein Beispiel für die Verwendung Java (da Ihr noch nicht entscheiden für eine bestimmte Sprache, ich gehe mit meiner besten) wo:
- MainVerticle: ist Ihre Bereitstellung verticle (hauptsächlich zum bereitstellen von anderen verticles)
- some.package.MyVerticle: ist dein richtiger verticle, beachten Sie, dass ich verwendet die id hier und nicht einer Instanz.
```
public class MainVerticle extends AbstractVerticle {  
  public void start() {
    vertx.deployVerticle("some.package.MyVerticle", res -> {
      if (res.succeeded()) {
        //Do whatever if deployment succeeded
      } else {
        //Handle deployment failure here...
      }
    });
  }
}
```
Nun, wenn es darum geht, "messaging-Fehler', es würde schwieriger sein, markieren Sie einen speziellen Fall, da es vorkommen kann an vielen Orten und zugunsten der beiden messaging endet.

Wenn Sie möchten, registrieren Sie einen Fehler Sachbearbeiterin beim senden einer Nachricht können Sie instanziieren ein MessageProducer<T> vertreten stream geschrieben werden können, dann registrieren Sie einen exception-handler auf:
```
EventBus eb = vertx.eventBus();
MessageProducer<String> sender = eb.sender("someAddress");
sender.exceptionHandler(e -> { 
  System.out.println("An error occured" + e.getCause()); 
});
sender.write("Hello...");
```
Auf der anderen Seite, können Sie behandeln Fehlerfall beim Lesen der empfangenen Nachrichten, die ziemlich viel die gleiche Weise, aber mit einem MessageConsumer<T> dieser Zeit:
```
EventBus eb = vertx.eventBus();
MessageConsumer<String> receiver = eb.consumer("someAddress");
receiver.exceptionHandler(e -> { 
  System.out.println("An error occured while readeing data" + e.getCause()); 
}).handler(msg -> {
  System.out.println("A message has been received: " + msg.body());
});
```
- Ihre Antwort deckt einige der Themen ist aber noch nicht abgeschlossen und die fehlende Fall ist die eine, die interessieren mich am meisten. Was passiert, wenn eine Ausnahme geworfen wird, in einer Verbraucher-handler auf, wenn die Verarbeitung der Nachricht? Was wäre, wenn " - System.aus.println("Nachricht empfangen:" + msg.Körper());" eine exception wirft?
- Was ist, wenn der code in der exceptionHandler löst eine Ausnahme erneut?
InformationsquelleAutor tmarwen

Um ein bisschen zu der vorherigen Antwort, wenn Sie reagieren wollen, um alle nicht abgefangene Ausnahmen, registrieren Sie den handler auf vertx Objekt wie folgt:

vertx.exceptionHandler(new Handler<Throwable>() {       
    @Override
    public void handle(Throwable event) {
        //do what you meant to do on uncaught exception, e.g.:
        System.err.println("Error");
        someLogger.error(event + " throws exception: " + event.getStackTrace());
    }
});

InformationsquelleAutor stijena

1

Lief ich in etwas ähnlich wie diese. Wenn eine Ausnahme passiert, als Teil der Verarbeitung einer Nachricht in einem Verticle, ich wollte nur eine Antwort mit der Ausnahme.

Die Idee ist einfach, sprudeln die Ausnahmen, die alle den Weg zurück zum Einstiegspunkt in die app, wo eine Entscheidung getroffen werden kann, was zu tun mit dem scheitern, während die Erfassung des gesamten Stapels auf dem Weg.

Um es zu erreichen, schrieb ich diese Funktion:
```
protected ReplyException buildReplyException(Throwable cause, String message)
    {
        ReplyException ex = new ReplyException(ReplyFailure.RECIPIENT_FAILURE, -1, message);
        ex.initCause(cause);
        return ex;
    }
```
Die ich dann verwenden, um zu bauen Handler oder reply-Handler, wie diese:
```
reply -> {
    if (reply.succeeded()) {
        message.reply(true);
    } else {
        message.reply(buildReplyException(reply.cause(), ""));
    }
});
```
Dieser Weg, der Kerl, der geschickt die original-Nachricht wird eine fehlgeschlagene Reaktion, die enthält eine Ursache, das ist eine Ausnahme, die hat ein full-stack-trace-aufgefüllt auf es.

Dieser Ansatz funktionierte sehr gut für mich, um Fehler während der Verarbeitung von Nachrichten.

InformationsquelleAutor Juan Bustamante

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.