audio2face3d-server 0.1.0

Audio2Face-3D compatible gRPC server
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#![cfg(feature = "native")]
use audio2face3d_server::{
    Server, ServerError,
    config::{BackendKind, Config},
};
/// Run with AUDIO2FACE3D_LOG_MODEL pointing to a prepared Regression descriptor.
#[tokio::test]
#[ignore = "requires native SDK, GPU and prepared Regression model"]
async fn stopping_during_native_prepare_keeps_cleanup_owned() {
    let model = std::env::var_os("AUDIO2FACE3D_LOG_MODEL").expect("prepared model");
    let server = Server::builder(
        Config::builder(BackendKind::Regression)
            .optional_model(Some(model.into()))
            .shutdown_timeout_ms(1)
            .build()
            .unwrap(),
    )
    .build()
    .unwrap();
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let result = server.serve(listener, std::future::ready(())).await;
    let report = match result {
        Ok(report) => report,
        Err(ServerError::ShutdownTimeout { completion, .. }) => completion.await.unwrap(),
        Err(error) => panic!("{error}"),
    };
    assert_eq!(report.inference_requests, 0);
    assert_eq!(report.inference_workers_started, 0);
}

#[tokio::test]
#[ignore = "requires AUDIO2FACE3D_LOG_MODEL pointing to a prepared Regression descriptor"]
async fn unavailable_native_configuration_fails_prepare_before_serving() {
    use audio2face3d::{
        Audio2Face3DContext,
        runtime::{NativeRuntimeConfig, NativeSearchPolicy},
    };
    let model = std::env::var_os("AUDIO2FACE3D_LOG_MODEL").expect("prepared model");
    let context = Audio2Face3DContext::builder()
        .native_runtime(
            NativeRuntimeConfig::builder()
                .search_policy(NativeSearchPolicy::ExplicitOnly)
                .build()
                .unwrap(),
        )
        .build();
    let server = Server::builder(
        Config::builder(BackendKind::Regression)
            .optional_model(Some(model.into()))
            .build()
            .unwrap(),
    )
    .context(context.clone())
    .build()
    .unwrap();
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let result = tokio::time::timeout(
        std::time::Duration::from_secs(30),
        server.serve(listener, std::future::pending()),
    )
    .await
    .expect("prepare must fail promptly");
    match result {
        Err(ServerError::Prepare(status)) => {
            assert_eq!(status.code(), tonic::Code::FailedPrecondition)
        }
        _ => panic!("expected unavailable prepare failure"),
    }
    assert!(context.native_runtime_info().is_none());
}