pretty print bpf dump

Signed-off-by: Kuromesi <blackfacepan@163.com>

Author: Kuromesi

pkg/controller/workload/workload_processor.go

@@ -108,6 +108,10 @@ func (p *Processor) GetBpfCache() *bpf.Cache {
 	return p.bpf
 }
 
+func (p *Processor) GetHashName() *utils.HashName {
+	return p.hashName
+}
+
 func (p *Processor) processWorkloadResponse(rsp *service_discovery_v3.DeltaDiscoveryResponse, rbac *auth.Rbac) {
 	var err error
 

pkg/nets/nets.go

@@ -56,6 +56,14 @@ func ConvertPortToBigEndian(little uint32) uint32 {
 	return uint32(big16)
 }
 
+// ConvertPortToLittleEndian convert port to host order
+func ConvertPortToLittleEndian(big uint32) uint32 {
+	tmp := make([]byte, 2)
+	binary.LittleEndian.PutUint16(tmp, uint16(big))
+	little16 := binary.BigEndian.Uint16(tmp)
+	return uint32(little16)
+}
+
 func CopyIpByteFromSlice(dst *[16]byte, src []byte) {
 	len := len(src)
 	if len != 4 && len != 16 {

pkg/nets/nets_test.go

@@ -118,3 +118,21 @@ func TestCompareIpByte(t *testing.T) {
 		})
 	}
 }
+
+func TestConvertPortToLittleEndian(t *testing.T) {
+	tests := []struct {
+		input    uint32
+		expected uint32
+	}{
+		{8080, 8080},
+		{0x5678, 0x5678},
+	}
+
+	for _, test := range tests {
+		input := ConvertPortToBigEndian(test.input)
+		actual := ConvertPortToLittleEndian(input)
+		if actual != test.expected {
+			t.Errorf("ConvertPortToLittleEndian(%#x) = %#x; expected %#x", test.input, actual, test.expected)
+		}
+	}
+}

pkg/status/api.go

@@ -17,10 +17,16 @@
 package status
 
 import (
+	"encoding/json"
+	"fmt"
 	"net"
+	"strings"
 
 	"kmesh.net/kmesh/api/v2/workloadapi"
 	"kmesh.net/kmesh/api/v2/workloadapi/security"
+	"kmesh.net/kmesh/pkg/controller/workload/bpfcache"
+	"kmesh.net/kmesh/pkg/nets"
+	"kmesh.net/kmesh/pkg/utils"
 )
 
 type Workload struct {
@@ -183,3 +189,169 @@ func ConvertAuthorizationPolicy(p *security.Authorization) *AuthorizationPolicy
 
 	return out
 }
+
+type prettyArray[T any] []T
+
+func (a prettyArray[T]) MarshalJSON() ([]byte, error) {
+	prettified := make([]string, len(a))
+	for i, elem := range a {
+		prettified[i] = fmt.Sprintf("%v", elem)
+	}
+
+	return json.Marshal(strings.Join(prettified, ", "))
+}
+
+type BpfServiceValue struct {
+	// EndpointCount is the number of endpoints for each priority.
+	EndpointCount prettyArray[uint32] `json:"endpointCount"`
+	LbPolicy      string              `json:"lbPolicy"`
+	ServicePort   prettyArray[uint32] `json:"servicePort,omitempty"`
+	TargetPort    prettyArray[uint32] `json:"targetPort,omitempty"`
+	WaypointAddr  prettyArray[byte]   `json:"waypointAddr,omitempty"`
+	WaypointPort  uint32              `json:"waypointPort,omitempty"`
+}
+
+type BpfBackendValue struct {
+	Ip           prettyArray[byte] `json:"ip"`
+	ServiceCount uint32            `json:"serviceCount"`
+	Services     []string          `json:"services"`
+	WaypointAddr prettyArray[byte] `json:"waypointAddr,omitempty"`
+	WaypointPort uint32            `json:"waypointPort,omitempty"`
+}
+
+type BpfFrontendValue struct {
+	UpstreamId string `json:"upstreamId,omitempty"`
+}
+
+type BpfWorkloadPolicyValue struct {
+	PolicyIds []string `json:"policyIds,omitempty"`
+}
+
+type BpfEndpointValue struct {
+	BackendUid string `json:"backendUid,omitempty"`
+}
+
+type WorkloadBpfDump struct {
+	hashName *utils.HashName
+
+	WorkloadPolicies []BpfWorkloadPolicyValue `json:"workloadPolicies"`
+	Backends         []BpfBackendValue        `json:"backends"`
+	Endpoints        []BpfEndpointValue       `json:"endpoints"`
+	Frontends        []BpfFrontendValue       `json:"frontends"`
+	Services         []BpfServiceValue        `json:"services"`
+}
+
+func NewWorkloadBpfDump(hashName *utils.HashName) WorkloadBpfDump {
+	return WorkloadBpfDump{hashName: hashName}
+}
+
+func (wd WorkloadBpfDump) WithWorkloadPolicies(workloadPolicies []bpfcache.WorkloadPolicyValue) WorkloadBpfDump {
+	converted := make([]BpfWorkloadPolicyValue, 0, len(workloadPolicies))
+	for _, policy := range workloadPolicies {
+		policyIds := []string{}
+		for _, id := range policy.PolicyIds {
+			policyIds = append(policyIds, wd.hashName.NumToStr(id))
+		}
+		converted = append(converted, BpfWorkloadPolicyValue{
+			PolicyIds: policyIds,
+		})
+	}
+	wd.WorkloadPolicies = converted
+	return wd
+}
+
+func (wd WorkloadBpfDump) WithBackends(backends []bpfcache.BackendValue) WorkloadBpfDump {
+	converted := make([]BpfBackendValue, 0, len(backends))
+	for _, backend := range backends {
+		ip := []byte{}
+		for _, b := range backend.Ip {
+			ip = append(ip, b)
+		}
+		waypointAddr := []byte{}
+		if backend.WaypointAddr != [16]byte{} {
+			for _, b := range backend.WaypointAddr {
+				waypointAddr = append(waypointAddr, b)
+			}
+		}
+		bac := BpfBackendValue{
+			Ip:           ip,
+			ServiceCount: backend.ServiceCount,
+			WaypointAddr: waypointAddr,
+			WaypointPort: nets.ConvertPortToLittleEndian(backend.WaypointPort),
+		}
+		services := make([]string, 0, len(backend.Services))
+		for _, s := range backend.Services {
+			svc := wd.hashName.NumToStr(s)
+			if svc == "" {
+				continue
+			}
+			services = append(services, wd.hashName.NumToStr(s))
+		}
+		bac.Services = services
+		converted = append(converted, bac)
+	}
+	wd.Backends = converted
+	return wd
+}
+
+func (wd WorkloadBpfDump) WithEndpoints(endpoints []bpfcache.EndpointValue) WorkloadBpfDump {
+	converted := make([]BpfEndpointValue, 0, len(endpoints))
+	for _, endpoint := range endpoints {
+		converted = append(converted, BpfEndpointValue{
+			BackendUid: wd.hashName.NumToStr(endpoint.BackendUid),
+		})
+	}
+	wd.Endpoints = converted
+	return wd
+}
+
+func (wd WorkloadBpfDump) WithFrontends(frontends []bpfcache.FrontendValue) WorkloadBpfDump {
+	converted := make([]BpfFrontendValue, 0, len(frontends))
+	for _, frontend := range frontends {
+		converted = append(converted, BpfFrontendValue{
+			UpstreamId: wd.hashName.NumToStr(frontend.UpstreamId),
+		})
+	}
+	wd.Frontends = converted
+	return wd
+}
+
+func (wd WorkloadBpfDump) WithServices(services []bpfcache.ServiceValue) WorkloadBpfDump {
+	converted := make([]BpfServiceValue, 0, len(services))
+	for _, s := range services {
+		waypointAddr := []byte{}
+		if s.WaypointAddr != [16]byte{} {
+			for _, b := range s.WaypointAddr {
+				waypointAddr = append(waypointAddr, b)
+			}
+		}
+		svc := BpfServiceValue{
+			EndpointCount: []uint32{},
+			LbPolicy:      workloadapi.LoadBalancing_Mode_name[int32(s.LbPolicy)],
+			WaypointAddr:  waypointAddr,
+			WaypointPort:  nets.ConvertPortToLittleEndian(s.WaypointPort),
+		}
+
+		for _, c := range s.EndpointCount {
+			svc.EndpointCount = append(svc.EndpointCount, c)
+		}
+
+		for _, p := range s.ServicePort {
+			if p == 0 {
+				continue
+			}
+			svc.ServicePort = append(svc.ServicePort, nets.ConvertPortToLittleEndian(p))
+		}
+
+		for _, p := range s.TargetPort {
+			if p == 0 {
+				continue
+			}
+			svc.TargetPort = append(svc.TargetPort, nets.ConvertPortToLittleEndian(p))
+		}
+
+		converted = append(converted, svc)
+	}
+	wd.Services = converted
+	return wd
+}

pkg/status/status_server.go

@@ -38,7 +38,6 @@ import (
 	"kmesh.net/kmesh/pkg/constants"
 	"kmesh.net/kmesh/pkg/controller"
 	"kmesh.net/kmesh/pkg/controller/ads"
-	"kmesh.net/kmesh/pkg/controller/workload/bpfcache"
 	"kmesh.net/kmesh/pkg/logger"
 	"kmesh.net/kmesh/pkg/version"
 )
@@ -149,27 +148,19 @@ func (s *Server) checkAdsMode(w http.ResponseWriter) bool {
 	return true
 }
 
-type WorkloadBpfDump struct {
-	WorkloadPolicies []bpfcache.WorkloadPolicyValue
-	Backends         []bpfcache.BackendValue
-	Endpoints        []bpfcache.EndpointValue
-	Frontends        []bpfcache.FrontendValue
-	Services         []bpfcache.ServiceValue
-}
-
 func (s *Server) bpfWorkloadMaps(w http.ResponseWriter, r *http.Request) {
 	if !s.checkWorkloadMode(w) {
 		return
 	}
 	client := s.xdsClient
 	bpfMaps := client.WorkloadController.Processor.GetBpfCache()
-	workloadBpfDump := WorkloadBpfDump{
-		WorkloadPolicies: bpfMaps.WorkloadPolicyLookupAll(),
-		Backends:         bpfMaps.BackendLookupAll(),
-		Endpoints:        bpfMaps.EndpointLookupAll(),
-		Frontends:        bpfMaps.FrontendLookupAll(),
-		Services:         bpfMaps.ServiceLookupAll(),
-	}
+	workloadBpfDump := NewWorkloadBpfDump(s.xdsClient.WorkloadController.Processor.GetHashName()).
+		WithBackends(bpfMaps.BackendLookupAll()).
+		WithEndpoints(bpfMaps.EndpointLookupAll()).
+		WithFrontends(bpfMaps.FrontendLookupAll()).
+		WithServices(bpfMaps.ServiceLookupAll()).
+		WithWorkloadPolicies(bpfMaps.WorkloadPolicyLookupAll())
+
 	printWorkloadBpfDump(w, workloadBpfDump)
 }
 
@@ -458,9 +449,9 @@ func (s *Server) configDumpAds(w http.ResponseWriter, r *http.Request) {
 }
 
 type WorkloadDump struct {
-	Workloads []*Workload
-	Services  []*Service
-	Policies  []*AuthorizationPolicy
+	Workloads []*Workload            `json:"workloads"`
+	Services  []*Service             `json:"services"`
+	Policies  []*AuthorizationPolicy `json:"policies"`
 }
 
 func (s *Server) configDumpWorkload(w http.ResponseWriter, r *http.Request) {