Cómo controlar la suspensión y la reanudación

Las máquinas virtuales (VMs) se pueden suspender, reanudar, reiniciar y apagar. Cuando ocurre cualquiera de estos eventos, se ven afectados los publicadores, los suscriptores, los clientes de RPC y los servidores de RPC. En la figura 1, se muestra el ciclo de vida de un paquete de servicios:

Figura 1: Es el ciclo de vida de un paquete de servicios.

El ciclo de vida del paquete de servicios sigue esta secuencia:

1. Se llama al método new para crear el paquete de servicio.
2. El administrador del ciclo de vida inicia el paquete de servicio y, según la configuración de la orquestación, llama a on_start.
3. Cuando la VM se detiene o suspende y, según la configuración de la orquestación, el administrador del ciclo de vida llama a on_stop. La función on_stop debe detener los subprocesos de publicadores, suscriptores, clientes de RPC y servidores de RPC.
4. Cuando se reanuda la VM, on_start puede volver a crear los subprocesos si el paquete de servicios está configurado para que se inicie de nuevo con la configuración de orquestación.

Crea una configuración para controlar la suspensión y la reanudación

En el siguiente ejemplo, se muestra una configuración para controlar la suspensión y la reanudación:

# 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" }
}

En la que:

• WAIT_FOR_FINISH es el último estado de energía en el que el paquete de servicios debe esperar que los agentes de vehículos definidos por software (SDV) respondan.
• SUSPEND_TO_RAM_POST_FINISH indica que los agentes de SDV podrían cerrar o suspender la conexión para poder restablecerla de forma confiable cuando se reanude. Es importante no depender de SUSPEND_TO_RAM_POST_FINISH o POWER_OFF_POST_FINISH para llamar a onStop en la implementación del paquete de servicios y, en su lugar, depender de SUSPEND_TO_RAM_ENTER, POWER_OFF_ENTER y WAIT_FOR_FINISH.

Determina la disponibilidad del servicio

En el siguiente ejemplo, se muestra cómo usar la API de middleware en tu paquete de servicios para determinar si una unidad de servicio está disponible:

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.");
            }
        }

El objeto create_server_registration_event_stream es una API de middleware que se usa para crear un evento llamado unit_name. Se notifica este flujo de eventos de registro cuando una unidad de servicio está disponible.