import (
    "github.com/cilium/cilium/pkg/k8s"
)

// NewDaemon creates and returns a new Daemon with the parameters set in c.
func NewDaemon(dp datapath.Datapath) (*Daemon, *endpointRestoreState, error) {
    ...
    k8s.Configure(option.Config.K8sAPIServer, option.Config.K8sKubeConfigPath)
    ...

    k8s.Init()

    // Annotation of the k8s node must happen after discovery of the
    // PodCIDR range and allocation of the health IPs.
    k8s.Client().AnnotateNode(node.GetName(), node.GetIPv4AllocRange() ...)
}

func Configure(apiServer, kubeconfigPath string) {
        config.APIServer = apiServer
        config.KubeconfigPath = kubeconfigPath

        if IsEnabled() &&
                config.APIServer != "" &&
                !strings.HasPrefix(apiServer, "http") {
                config.APIServer = "http://" + apiServer
        }
}

// Init initializes the Kubernetes package. It is required to call Configure()
// beforehand.
func Init() error {
    if nodeName := os.Getenv(EnvNodeNameSpec); nodeName != "" {
        if n := waitForNodeInformation(nodeName); n != nil {
            nodeIP4 := n.GetNodeIP(false)
            Info("Received own node information from API server")

            useNodeCIDR(n)

        } else {
            // if node resource could not be received, fail if
            // PodCIDR requirement has been requested
            if option.Config.K8sRequireIPv4PodCIDR || option.Config.K8sRequireIPv6PodCIDR
                log.Fatal("Unable to derive PodCIDR from Kubernetes node resource, giving up")
        }

        // Annotate addresses will occur later since the user might
        // want to specify them manually
    } else if option.Config.K8sRequireIPv4PodCIDR || option.Config.K8sRequireIPv6PodCIDR
        return fmt.Errorf("node name must be specified via environment variable
                '%s' to retrieve Kubernetes PodCIDR range", EnvNodeNameSpec)

    return nil
}

// ParseNode parses a kubernetes node to a cilium node
func ParseNode(k8sNode *types.Node, source node.Source) *node.Node {
    newNode := &node.Node{
        Name:        k8sNode.Name,
    }

    if len(k8sNode.SpecPodCIDR) != 0
        if allocCIDR, err := cidr.ParseCIDR(k8sNode.SpecPodCIDR); err != nil
            scopedLog.WithError(err).Warn("Invalid PodCIDR value for node")
        else
            if allocCIDR.IP.To4() != nil
                newNode.IPv4AllocCIDR = allocCIDR
            else
                newNode.IPv6AllocCIDR = allocCIDR

    // Spec.PodCIDR takes precedence since it's
    // the CIDR assigned by k8s controller manager
    // In case it's invalid or empty then we fall back to our annotations.
    if newNode.IPv4AllocCIDR == nil {
        if ipv4CIDR, ok := k8sNode.Annotations[annotation.V4CIDRName]; !ok {
            scopedLog.Debug("Empty IPv4 CIDR annotation in node")
        else
            allocCIDR, err := cidr.ParseCIDR(ipv4CIDR)
            if err != nil {
                scopedLog.WithError(err).Error("BUG, invalid IPv4 annotation CIDR in node")
            else
                newNode.IPv4AllocCIDR = allocCIDR

    return newNode
}

// useNodeCIDR sets the ipv4-range and ipv6-range values values from the
// addresses defined in the given node.
func useNodeCIDR(n *node.Node) {
    node.SetIPv4AllocRange(n.IPv4AllocCIDR)
}

// SetIPv4AllocRange sets the IPv4 address pool to use when allocating
// addresses for local endpoints
func SetIPv4AllocRange(net *cidr.CIDR) {
    ipv4AllocRange = net
}