Der Prozess besteht normalerweise darin, dass **Sie in Ihrem Code definieren**, welche Nachricht Sie senden möchten, den **Body des Requests**.

Sie definieren auch auf irgendeine Weise, in welchen **Momenten** Ihre App diese Requests oder Events senden wird.

     */
    public boolean isRecoverable() {
        return severity == Severity.RECOVERABLE || severity == Severity.TRANSIENT;
    }

    /**
     * Checks if retry should be attempted
     *
     * @return true if retry is recommended
     */
    public boolean shouldRetry() {
        return severity == Severity.RECOVERABLE || severity == Severity.TRANSIENT;
    }

    /**

                                        + "Fix the logged issues or remove flag --fail-on-severity (-fos)."));
            }

            logResult(event.getSession());

            logStats(event.getSession());

            infoLine('-');
        }
    }

    private boolean isSingleVersionedReactor(MavenSession session) {
        boolean result = true;

						// re-init the watch channel.
						goto outerLoop
					}
					for _, event := range watchResp.Events {
						isCreateEvent := event.IsModify() || event.IsCreate()
						isDeleteEvent := event.Type == etcd.EventTypeDelete

						switch {
						case isCreateEvent:
							ch <- iamWatchEvent{
								isCreated: true,
								keyPath:   string(event.Kv.Key),
							}
						case isDeleteEvent:
							ch <- iamWatchEvent{

/// tip

Note that we're using async/await with the new `AsyncClient` - the request is asynchronous.

///

/// warning

If your application relies on lifespan events, the `AsyncClient` won't trigger these events. To ensure they are triggered, use `LifespanManager` from <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.

///

        return hasProblemsFor(BuilderProblem.Severity.FATAL);
    }

    /**
     * Returns {@code true} if there is at least one problem collected with severity equal or more severe than
     * passed in severity.
     */
    default boolean hasProblemsFor(BuilderProblem.Severity severity) {
        requireNonNull(severity, "severity");
        for (BuilderProblem.Severity s : BuilderProblem.Severity.values()) {

                    problems.add(new ModelProblemCollectorRequest(Severity.ERROR, Version.V20)
                            .setMessage("Malformed POM " + modelSource.getLocation() + ": " + e.getMessage())
                            .setException(e));
                } else {
                    problems.add(new ModelProblemCollectorRequest(Severity.WARNING, Version.V20)

            final int bytes) {
        TransferEvent event = new TransferEvent.Builder(session, resource)
                .setType(TransferEvent.EventType.PROGRESSED)
                .setTransferredBytes(bytes)
                .build();
        startLatch.countDown();
        try {
            listener.transferProgressed(event);
        } catch (TransferCancelledException e) {
        }

            return true;
        }

        addViolation(problems, Severity.ERROR, fieldName, sourceHint, "is missing");

        return false;
    }

    private static boolean validateBannedCharacters(
            SettingsProblemCollector problems,
            String fieldName,
            Severity severity,
            String string,
            String sourceHint,
            String banned) {

/// tip | Tipp

Beachten Sie, dass wir async/await mit dem neuen `AsyncClient` verwenden – der Request ist asynchron.

///

/// warning | Achtung