func()

in pkg/skoop/collector/manager/manager.go [160:252]
80 lines of code
11 McCabe index (conditional complexity)

func (m *simplePodCollectorManager) buildCache(nodeName string) error {
	dump, err := m.collectNodeStackDump(nodeName)
	if err != nil {
		return err
	}

	netnsMap := map[string]netstack.NetNSInfo{}

	for _, netns := range dump.Netns {
		netnsMap[netns.Netns] = netns
	}

	if _, ok := netnsMap[hostnsKey]; !ok {
		return fmt.Errorf("cannot get host netns info for node %s", nodeName)
	}

	hostNetNS := netnsMap[hostnsKey]
	nodeInfo := &k8s.NodeInfo{
		SubNetNSInfo: dump.Netns,
		NetNS:        netstack.NetNS{NetNSInfo: &hostNetNS},
		NodeMeta: k8s.NodeMeta{
			NodeName: nodeName,
		},
	}

	nodeInfo.Router = netstack.NewSimulateRouter(nodeInfo.NetNSInfo.RuleInfo, nodeInfo.NetNSInfo.RouteInfo, nodeInfo.NetNSInfo.Interfaces)
	nodeInfo.IPVS = netstack.NewIPVS(nodeInfo.NetNSInfo.IPVSInfo)
	nodeInfo.IPTables = netstack.ParseIPTables(nodeInfo.NetNSInfo.IptablesInfo)
	if err != nil {
		return err
	}
	nodeInfo.IPSetManager, err = netstack.NewIPSetManager(nodeInfo.NetNSInfo.IpsetInfo)
	if err != nil {
		return err
	}
	nodeInfo.Interfaces = nodeInfo.NetNSInfo.Interfaces
	nodeInfo.Neighbour = netstack.NewNeigh(nodeInfo.NetNSInfo.Interfaces)
	nodeInfo.Netfilter = netstack.NewSimulateNetfilter(netstack.SimulateNetfilterContext{
		IPTables: nodeInfo.IPTables,
		IPSet:    nodeInfo.IPSetManager,
		Router:   nodeInfo.Router,
		IPVS:     nodeInfo.IPVS,
	})

	m.nodeCache[nodeName] = nodeInfo

	for _, p := range dump.Pods {
		podInfo := &k8s.Pod{
			PodMeta: k8s.PodMeta{
				Namespace:   p.PodNamespace,
				PodName:     p.PodName,
				HostNetwork: p.NetworkMode == "host",
				NodeName:    nodeName,
			},
		}

		if podInfo.HostNetwork {
			podInfo.NetNSInfo = nodeInfo.NetNSInfo
		} else {
			podNetNS, ok := netnsMap[p.Netns]
			if !ok {
				return fmt.Errorf("cannot get pod netns info for pod %s/%s, node %s", p.PodNamespace, p.PodName, nodeName)
			}
			podInfo.NetNSInfo = &podNetNS
		}

		podInfo.IPVS = netstack.NewIPVS(podInfo.NetNSInfo.IPVSInfo)
		podInfo.IPTables = netstack.ParseIPTables(podInfo.NetNSInfo.IptablesInfo)
		if err != nil {
			return err
		}
		podInfo.IPSetManager, err = netstack.NewIPSetManager(podInfo.NetNSInfo.IpsetInfo)
		if err != nil {
			return err
		}

		podInfo.Router = netstack.NewSimulateRouter(podInfo.NetNSInfo.RuleInfo, podInfo.NetNSInfo.RouteInfo, podInfo.NetNSInfo.Interfaces)
		podInfo.Interfaces = podInfo.NetNSInfo.Interfaces
		podInfo.Neighbour = netstack.NewNeigh(podInfo.NetNSInfo.Interfaces)
		podInfo.Netfilter = netstack.NewSimulateNetfilter(netstack.SimulateNetfilterContext{
			IPTables: podInfo.IPTables,
			IPSet:    podInfo.IPSetManager,
			Router:   podInfo.Router,
			IPVS:     podInfo.IPVS,
		})

		podKey := fmt.Sprintf("%s/%s", p.PodNamespace, p.PodName)

		m.podCache[podKey] = podInfo
	}

	return nil
}