Make statsmanager and interfacemanager independent. Add reconnect logic for EventMonitoring

src/vpp/vpp_iface.go

@@ -4,6 +4,7 @@ package vpp
 
 import (
 	"os"
+	"time"
 
 	"go.fd.io/govpp/api"
 	interfaces "go.fd.io/govpp/binapi/interface"
@@ -28,8 +29,10 @@ type InterfaceEventCallback func(details []InterfaceDetails)
 
 // InterfaceManager handles interface-related VPP operations
 type InterfaceManager struct {
-	client        *VPPClient
-	eventCallback InterfaceEventCallback
+	client         *VPPClient
+	eventCallback  InterfaceEventCallback
+	running        bool
+	watchingEvents bool
 }
 
 // NewInterfaceManager creates a new interface manager
@@ -44,6 +47,82 @@ func (im *InterfaceManager) SetEventCallback(callback InterfaceEventCallback) {
 	im.eventCallback = callback
 }
 
+// InitializeEventWatching starts event watching and retrieves initial interface details
+func (im *InterfaceManager) InitializeEventWatching() error {
+	if !im.client.IsConnected() {
+		return &VPPError{Message: "VPP client not connected"}
+	}
+
+	// Start watching interface events
+	if err := im.StartEventWatcher(); err != nil {
+		logger.Debugf("Failed to start interface event watching: %v", err)
+		return err
+	}
+
+	logger.Debugf("Interface event watching started")
+
+	// Get initial interface details
+	if details, err := im.GetAllInterfaceDetails(); err != nil {
+		logger.Debugf("Failed to get initial interface details: %v", err)
+		return err
+	} else {
+		logger.Debugf("Retrieved initial interface details for %d interfaces", len(details))
+		if im.eventCallback != nil {
+			im.eventCallback(details)
+		}
+	}
+
+	im.watchingEvents = true
+	return nil
+}
+
+// StartEventMonitoring starts continuous monitoring for VPP connection and restarts event watching as needed
+func (im *InterfaceManager) StartEventMonitoring() {
+	if im.running {
+		logger.Debugf("Interface event monitoring already running")
+		return
+	}
+
+	im.running = true
+	go im.eventMonitoringRoutine()
+}
+
+// StopEventMonitoring stops the event monitoring routine
+func (im *InterfaceManager) StopEventMonitoring() {
+	im.running = false
+}
+
+// eventMonitoringRoutine continuously monitors VPP connection and manages event watching
+func (im *InterfaceManager) eventMonitoringRoutine() {
+	logger.Debugf("Starting interface event monitoring routine")
+
+	for {
+		if !im.running {
+			logger.Debugf("Interface event monitoring routine stopping")
+			break
+		}
+
+		if im.client.IsConnected() {
+			if !im.watchingEvents {
+				if err := im.InitializeEventWatching(); err != nil {
+					logger.Debugf("Failed to initialize interface event watching: %v", err)
+				} else {
+					logger.Debugf("Interface event watching restarted after reconnection")
+				}
+			}
+		} else {
+			if im.watchingEvents {
+				logger.Debugf("VPP connection lost, interface event watching will restart on reconnection")
+				im.watchingEvents = false
+			}
+		}
+
+		time.Sleep(time.Second)
+	}
+
+	logger.Debugf("Interface event monitoring routine ended")
+}
+
 // GetAllInterfaceDetails retrieves detailed information for all interfaces
 func (im *InterfaceManager) GetAllInterfaceDetails() ([]InterfaceDetails, error) {
 	if !im.client.IsConnected() {