Anhalten und Fortsetzen verarbeiten

Virtuelle Maschinen (VMs) können angehalten, fortgesetzt, neu gestartet und heruntergefahren werden. Wenn eines dieser Ereignisse eintritt, sind Publisher, Abonnenten, RPC-Clients und RPC-Server betroffen. Abbildung 1 zeigt den Lebenszyklus eines Dienstpakets:

Abbildung 1. Lebenszyklus eines Service-Pakets.

Der Lebenszyklus eines Servicepakets folgt dieser Reihenfolge:

1. Die Methode new wird aufgerufen, um das Dienstpaket zu erstellen.
2. Der Lifecycle-Manager startet das Dienstbündel und ruft je nach den Einstellungen in der Orchestrierungskonfiguration on_start auf.
3. Wenn die VM beendet oder angehalten wird, ruft der Lifecycle Manager je nach den Einstellungen in der Orchestrierungskonfiguration on_stop auf. Die Funktion on_stop sollte die Threads für Publisher, Abonnenten, RPC-Clients und RPC-Server beenden.
4. Wenn die VM fortgesetzt wird, kann on_start die Threads neu erstellen, wenn das Dienst-Bundle so konfiguriert ist, dass es durch die Orchestrierungskonfiguration neu gestartet wird.

Konfiguration zum Verarbeiten von Anhalten und Fortsetzen erstellen

Das folgende Beispiel zeigt eine Konfiguration für das Anhalten und Fortsetzen:

# Start `auto_start` service bundles when system is started.
state {
    condition {
        or {
            power_state: "ON"
            power_state: "POWER_OFF_EXIT"
            power_state: "SUSPEND_TO_RAM_EXIT"
        }
    }
    groups_states { started: "auto_start" }
}

# Stop `auto_start` service bundles when system is suspending to RAM.
state {
    condition {
        or {
            power_state: "SUSPEND_TO_RAM_ENTER"
            power_state: "WAIT_FOR_FINISH"
            power_state: "SUSPEND_TO_RAM_POST_FINISH"
        }
    }
    groups_states { created: "auto_start" }
}

Wobei:

• WAIT_FOR_FINISH ist der letzte Stromversorgungsstatus, in dem das Dienstpaket erwarten sollte, dass Software Defined Vehicle (SDV)-Agents reagieren.
• SUSPEND_TO_RAM_POST_FINISH gibt an, dass SDV-Agents die Verbindung möglicherweise schließen oder unterbrechen, um sie beim Fortsetzen zuverlässig wiederherstellen zu können. Es ist wichtig, sich bei der Implementierung des Dienstbündels nicht auf SUSPEND_TO_RAM_POST_FINISH oder POWER_OFF_POST_FINISH zu verlassen, um onStop aufzurufen, sondern stattdessen auf SUSPEND_TO_RAM_ENTER, POWER_OFF_ENTER und WAIT_FOR_FINISH.

Dienstverfügbarkeit ermitteln

Das folgende Beispiel zeigt, wie Sie die Middleware-API in Ihrem Service-Bundle verwenden, um festzustellen, ob eine Serviceeinheit verfügbar ist:

let mut registration_event_stream =  sdv::mw::clientlib::create_server_registration_event_stream(
        sdv_comms,
        // Descriptor of type sdv::mw::clientlib::rpc_descriptor::client::Descriptor
        // that binds a specific RPC client type to a communication channel.
        client_descriptor,
    )
    .await
    .expect("unable to generate a registration event");

match registration_event_stream.next().await {
            Some(sdv::mw::Availability::Available) => {
                info!("{unit_name} became Available.");
                // Create client/subscriber
            }
            Some(sdv::mw::Availability::Unavailable) => {
                info!("{unit_name} became Unavailable.");
                // Destroy client/subscriber
            }
            None => {
                warn!("Registration event stream for {unit_name} terminated.
                Stopping monitoring for this variant.");
            }
        }

Die create_server_registration_event_stream ist eine Middleware-API, mit der das Ereignis unit_name erstellt wird. Dieser Registrierungsereignisstream wird benachrichtigt, wenn eine Serviceeinheit verfügbar wird.