vhost 0.16.0

a pure rust library for vdpa, vhost and vhost-user
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Copyright (C) 2019 Alibaba Cloud Computing. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

//! Traits and Structs for vhost-user backend.

use std::sync::Arc;

use super::connection::{Endpoint, Listener};
use super::message::*;
use super::{BackendReqHandler, Result, VhostUserBackendReqHandler};

/// Vhost-user backend side connection listener.
pub struct BackendListener<'a, S: VhostUserBackendReqHandler> {
    listener: &'a mut Listener,
    backend: Option<Arc<S>>,
}

/// Sets up a listener for incoming frontend connections, and handles construction
/// of a Backend on success.
impl<'a, S: VhostUserBackendReqHandler> BackendListener<'a, S> {
    /// Create a unix domain socket for incoming frontend connections.
    pub fn new(listener: &'a mut Listener, backend: Arc<S>) -> Result<Self> {
        Ok(BackendListener {
            listener,
            backend: Some(backend),
        })
    }

    /// Accept an incoming connection from the frontend, returning Some(Backend) on
    /// success, or None if the socket is nonblocking and no incoming connection
    /// was detected
    pub fn accept(&mut self) -> Result<Option<BackendReqHandler<S>>> {
        if let Some(fd) = self.listener.accept()? {
            return Ok(Some(BackendReqHandler::new(
                Endpoint::<VhostUserMsgHeader<FrontendReq>>::from_stream(fd),
                self.backend.take().unwrap(),
            )));
        }
        Ok(None)
    }

    /// Change blocking status on the listener.
    pub fn set_nonblocking(&self, block: bool) -> Result<()> {
        self.listener.set_nonblocking(block)
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Mutex;

    use super::*;
    use crate::vhost_user::dummy_backend::DummyBackendReqHandler;

    #[test]
    fn test_backend_listener_set_nonblocking() {
        let backend = Arc::new(Mutex::new(DummyBackendReqHandler::new()));
        let mut listener =
            Listener::new("/tmp/vhost_user_lib_unit_test_backend_nonblocking", true).unwrap();
        let backend_listener = BackendListener::new(&mut listener, backend).unwrap();

        backend_listener.set_nonblocking(true).unwrap();
        backend_listener.set_nonblocking(false).unwrap();
        backend_listener.set_nonblocking(false).unwrap();
        backend_listener.set_nonblocking(true).unwrap();
        backend_listener.set_nonblocking(true).unwrap();
    }

    #[cfg(feature = "vhost-user-frontend")]
    #[test]
    fn test_backend_listener_accept() {
        use super::super::Frontend;

        let path = "/tmp/vhost_user_lib_unit_test_backend_accept";
        let backend = Arc::new(Mutex::new(DummyBackendReqHandler::new()));
        let mut listener = Listener::new(path, true).unwrap();
        let mut backend_listener = BackendListener::new(&mut listener, backend).unwrap();

        backend_listener.set_nonblocking(true).unwrap();
        assert!(backend_listener.accept().unwrap().is_none());
        assert!(backend_listener.accept().unwrap().is_none());

        let _frontend = Frontend::connect(path, 1).unwrap();
        let _backend = backend_listener.accept().unwrap().unwrap();
    }
}