feat: add kernel version check

Author: lzf575

agent/src/rpc/synchronizer.rs

@@ -1572,7 +1572,6 @@ impl Synchronizer {
                     } else {
                         match Self::upgrade(&running, &session, &revision, &id, &agent_state).await {
                             Ok(true) => {
-                                agent_state.terminate();
                                 warn!("agent upgrade is successful and restarts normally, deepflow-agent restart...");
                                 crate::utils::clean_and_exit(NORMAL_EXIT_WITH_RESTART);
                                 return;

agent/src/trident.rs

@@ -125,6 +125,8 @@ use integration_skywalking::SkyWalkingExtra;
 use packet_sequence_block::BoxedPacketSequenceBlock;
 use pcap_assembler::{BoxedPcapBatch, PcapAssembler};
 
+#[cfg(feature = "enterprise")]
+use enterprise_utils::utils::{kernel_version_check, ActionFlags};
 use public::{
     buffer::BatchedBox,
     debug::QueueDebugger,
@@ -269,16 +271,6 @@ impl AgentState {
         }
     }
 
-    pub fn terminate(&self) {
-        if !self.terminated.swap(true, Ordering::Relaxed) {
-            // log only the first time
-            info!("Agent state changed to {:?}", State::Terminated);
-        }
-        let sg = self.state.lock().unwrap();
-        self.notifier.notify_one();
-        info!("Agent terminate with state: {:?}", State::from(sg.0));
-    }
-
     pub fn update_config(&self, config: ChangedConfig) {
         if self.terminated.load(Ordering::Relaxed) {
             // when state is Terminated, main thread should still be notified for exiting
@@ -629,6 +621,20 @@ impl Trident {
         Ok(Trident { state, handle })
     }
 
+    #[cfg(feature = "enterprise")]
+    fn kernel_version_check(state: &AgentState, exception_handler: &ExceptionHandler) {
+        let action = kernel_version_check();
+        if action.contains(ActionFlags::TERMINATE) {
+            exception_handler.set(Exception::KernelVersionCircuitBreaker);
+            crate::utils::clean_and_exit(1);
+        } else if action.contains(ActionFlags::MELTDOWN) {
+            exception_handler.set(Exception::KernelVersionCircuitBreaker);
+            state.melt_down();
+        } else if action.contains(ActionFlags::ALARM) {
+            exception_handler.set(Exception::KernelVersionCircuitBreaker);
+        }
+    }
+
     fn run(
         state: Arc<AgentState>,
         ctrl_ip: IpAddr,
@@ -894,6 +900,9 @@ impl Trident {
             platform_synchronizer.start();
         }
 
+        #[cfg(feature = "enterprise")]
+        Trident::kernel_version_check(&state, &exception_handler);
+
         let mut components: Option<Components> = None;
         let mut first_run = true;
         let mut config_initialized = false;
@@ -1176,7 +1185,6 @@ impl Trident {
     }
 
     pub fn stop(&mut self) {
-        self.state.terminate();
         info!("Agent stopping");
         crate::utils::clean_and_exit(0);
     }

agent/src/utils/guard.rs

@@ -553,6 +553,9 @@ impl Guard {
                 } else if exception_handler.has(Exception::FreeDiskCircuitBreaker) {
                     warn!("Set the state to melt_down when the free disk exceeds the threshold.");
                     state.melt_down();
+                } else if exception_handler.has(Exception::KernelVersionCircuitBreaker) {
+                    warn!("Set the state to melt_down when the kernel version circuit breaker.");
+                    state.melt_down();
                 } else {
                     state.recover();
                 }