[rust-vmm/event-manager 7/7] migrate Metrics & API

This series of 7 commits migrates Firecracker from using local
'polly' crate, to using 'rust-vmm/event-manager' crate.

Note: The project doesn't build with only part of this patchset.

Signed-off-by: Adrian Catangiu <[email protected]>

Author: acatangiu

Cargo.lock

@@ -9,13 +9,13 @@ homepage = "https://firecracker-microvm.github.io/"
 license = "Apache-2.0"
 
 [dependencies]
+event-manager = ">=0.2.1"
 libc = ">=0.2.39"
 timerfd = ">=1.0"
 
 api_server = { path = "../api_server" }
 logger = { path = "../logger" }
 mmds = { path = "../mmds" }
-polly = { path = "../polly" }
 seccompiler = { path = "../seccompiler" }
 snapshot = { path = "../snapshot"}
 utils = { path = "../utils" }

src/firecracker/Cargo.toml

@@ -10,19 +10,16 @@ use std::sync::{Arc, Mutex};
 use std::thread;
 
 use api_server::{ApiRequest, ApiResponse, ApiServer};
+use event_manager::{EventOps, Events, MutEventSubscriber, SubscriberOps};
 use logger::{error, warn, ProcessTimeReporter};
 use mmds::MMDS;
-use polly::event_manager::{EventManager, Subscriber};
 use seccompiler::BpfThreadMap;
-use utils::{
-    epoll::{EpollEvent, EventSet},
-    eventfd::EventFd,
-};
+use utils::{epoll::EventSet, eventfd::EventFd};
 use vmm::{
     resources::VmResources,
     rpc_interface::{PrebootApiController, RuntimeApiController, VmmAction},
     vmm_config::instance_info::InstanceInfo,
-    ExitCode, Vmm,
+    EventManager, ExitCode, Vmm,
 };
 
 struct ApiServerAdapter {
@@ -49,10 +46,7 @@ impl ApiServerAdapter {
             to_api,
             controller: RuntimeApiController::new(vm_resources, vmm.clone()),
         }));
-        event_manager
-            .add_subscriber(api_adapter)
-            .expect("Cannot register the api event to the event manager.");
-
+        event_manager.add_subscriber(api_adapter);
         loop {
             event_manager
                 .run()
@@ -72,9 +66,9 @@ impl ApiServerAdapter {
             .expect("one-shot channel closed");
     }
 }
-impl Subscriber for ApiServerAdapter {
+impl MutEventSubscriber for ApiServerAdapter {
     /// Handle a read event (EPOLLIN).
-    fn process(&mut self, event: &EpollEvent, _: &mut EventManager) {
+    fn process(&mut self, event: Events, _: &mut EventOps) {
         let source = event.fd();
         let event_set = event.event_set();
 
@@ -115,11 +109,10 @@ impl Subscriber for ApiServerAdapter {
         }
     }
 
-    fn interest_list(&self) -> Vec<EpollEvent> {
-        vec![EpollEvent::new(
-            EventSet::IN,
-            self.api_event_fd.as_raw_fd() as u64,
-        )]
+    fn init(&mut self, ops: &mut EventOps) {
+        if let Err(e) = ops.add(Events::new(&self.api_event_fd, EventSet::IN)) {
+            error!("Failed to register activate event: {}", e);
+        }
     }
 }
 
@@ -178,9 +171,7 @@ pub(crate) fn run_with_api(
     let mut event_manager = EventManager::new().expect("Unable to create EventManager");
     // Create the firecracker metrics object responsible for periodically printing metrics.
     let firecracker_metrics = Arc::new(Mutex::new(super::metrics::PeriodicMetrics::new()));
-    event_manager
-        .add_subscriber(firecracker_metrics.clone())
-        .expect("Cannot register the metrics event to the event manager.");
+    event_manager.add_subscriber(firecracker_metrics.clone());
 
     // Configure, build and start the microVM.
     let build_result = match config_json {

src/firecracker/src/api_server_adapter.rs

@@ -10,20 +10,19 @@ use std::path::PathBuf;
 use std::process;
 use std::sync::{Arc, Mutex};
 
+use event_manager::SubscriberOps;
 use logger::{error, info, warn, IncMetric, ProcessTimeReporter, LOGGER, METRICS};
-use polly::event_manager::EventManager;
 use seccompiler::BpfThreadMap;
 use snapshot::Snapshot;
 use utils::arg_parser::{ArgParser, Argument, Arguments};
 use utils::terminal::Terminal;
 use utils::validators::validate_instance_id;
-use vmm::resources::VmResources;
 use vmm::seccomp_filters::{get_filters, SeccompConfig};
 use vmm::signal_handler::register_signal_handlers;
 use vmm::version_map::{FC_VERSION_TO_SNAP_VERSION, VERSION_MAP};
 use vmm::vmm_config::instance_info::{InstanceInfo, VmState};
 use vmm::vmm_config::logger::{init_logger, LoggerConfig, LoggerLevel};
-use vmm::ExitCode;
+use vmm::{resources::VmResources, EventManager, ExitCode};
 
 // The reason we place default API socket under /run is that API socket is a
 // runtime file.
@@ -464,9 +463,7 @@ fn run_without_api(
 
     // Create the firecracker metrics object responsible for periodically printing metrics.
     let firecracker_metrics = Arc::new(Mutex::new(metrics::PeriodicMetrics::new()));
-    event_manager
-        .add_subscriber(firecracker_metrics.clone())
-        .expect("Cannot register the metrics event to the event manager.");
+    event_manager.add_subscriber(firecracker_metrics.clone());
 
     // Build the microVm. We can ignore VmResources since it's not used without api.
     let (_, vmm) = match build_microvm_from_json(

src/firecracker/src/main.rs

@@ -4,10 +4,10 @@
 use std::os::unix::io::AsRawFd;
 use std::time::Duration;
 
+use event_manager::{EventOps, Events, MutEventSubscriber};
 use logger::{error, warn, IncMetric, METRICS};
-use polly::event_manager::{EventManager, Subscriber};
 use timerfd::{ClockId, SetTimeFlags, TimerFd, TimerState};
-use utils::epoll::{EpollEvent, EventSet};
+use utils::epoll::EventSet;
 
 /// Metrics reporting period.
 pub(crate) const WRITE_METRICS_PERIOD_MS: u64 = 60000;
@@ -60,9 +60,9 @@ impl PeriodicMetrics {
     }
 }
 
-impl Subscriber for PeriodicMetrics {
+impl MutEventSubscriber for PeriodicMetrics {
     /// Handle a read event (EPOLLIN).
-    fn process(&mut self, event: &EpollEvent, _: &mut EventManager) {
+    fn process(&mut self, event: Events, _: &mut EventOps) {
         let source = event.fd();
         let event_set = event.event_set();
 
@@ -85,11 +85,10 @@ impl Subscriber for PeriodicMetrics {
         }
     }
 
-    fn interest_list(&self) -> Vec<EpollEvent> {
-        vec![EpollEvent::new(
-            EventSet::IN,
-            self.write_metrics_event_fd.as_raw_fd() as u64,
-        )]
+    fn init(&mut self, ops: &mut EventOps) {
+        if let Err(e) = ops.add(Events::new(&self.write_metrics_event_fd, EventSet::IN)) {
+            error!("Failed to register metrics event: {}", e);
+        }
     }
 }
 
@@ -98,48 +97,13 @@ pub mod tests {
     use std::sync::{Arc, Mutex};
 
     use super::*;
-    use polly::event_manager::EventManager;
-    use utils::eventfd::EventFd;
-
-    #[test]
-    fn test_interest_list() {
-        let metrics = PeriodicMetrics::new();
-        let interest_list = metrics.interest_list();
-        assert_eq!(interest_list.len(), 1);
-        assert_eq!(
-            interest_list[0].data() as i32,
-            metrics.write_metrics_event_fd.as_raw_fd()
-        );
-        assert_eq!(
-            EventSet::from_bits(interest_list[0].events()).unwrap(),
-            EventSet::IN
-        );
-    }
+    use event_manager::{EventManager, SubscriberOps};
 
     #[test]
     fn test_periodic_metrics() {
         let mut event_manager = EventManager::new().expect("Unable to create EventManager");
-        let mut metrics = PeriodicMetrics::new();
-
-        // Test invalid read event.
-        let unrelated_object = EventFd::new(libc::EFD_NONBLOCK).unwrap();
-        let unrelated_event = EpollEvent::new(EventSet::IN, unrelated_object.as_raw_fd() as u64);
-        metrics.process(&unrelated_event, &mut event_manager);
-        // No flush happened.
-        assert_eq!(metrics.flush_counter, 0);
-
-        // Test unsupported event type.
-        let unsupported_event = EpollEvent::new(
-            EventSet::OUT,
-            metrics.write_metrics_event_fd.as_raw_fd() as u64,
-        );
-        metrics.process(&unsupported_event, &mut event_manager);
-        assert_eq!(metrics.flush_counter, 0);
-
-        let metrics = Arc::new(Mutex::new(metrics));
-        event_manager
-            .add_subscriber(metrics.clone())
-            .expect("Cannot register the metrics event to the event manager.");
+        let metrics = Arc::new(Mutex::new(PeriodicMetrics::new()));
+        event_manager.add_subscriber(metrics.clone());
 
         let flush_period_ms = 50;
         metrics