Virtual kubelet: working queue-based endpointslice reflection

Author: giorio94

pkg/liqonet/test/doc.go pkg/liqonet/ipam/fake/doc.gopkg/liqonet/test/doc.go renamed to pkg/liqonet/ipam/fake/doc.go

@@ -12,5 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package test provides a mock type for IPAM module
-package test
+// Package fake implements fake IPAM grpc interfaces for testing purposes.
+package fake

pkg/liqonet/ipam/fake/ipam.go

@@ -0,0 +1,99 @@
+// Copyright 2019-2021 The Liqo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fake
+
+import (
+	"context"
+	"fmt"
+
+	grpc "google.golang.org/grpc"
+
+	"github.com/liqotech/liqo/pkg/liqonet/ipam"
+	"github.com/liqotech/liqo/pkg/liqonet/utils"
+)
+
+// IPAMClient provides a mock implementation of the IPAMClient interface for testing purposes.
+type IPAMClient struct {
+	localRemappedPodCIDR  string
+	remoteRemappedPodCIDR string
+	enforceSingleRequest  bool
+
+	pods      map[string]string
+	endpoints map[string]string
+}
+
+// NewIPAMClient returns a new fake IPAMClient.
+func NewIPAMClient(localRemappedPodCIDR, remoteRemappedPodCIDR string, enforceSingleRequest bool) *IPAMClient {
+	return &IPAMClient{
+		localRemappedPodCIDR:  localRemappedPodCIDR,
+		remoteRemappedPodCIDR: remoteRemappedPodCIDR,
+		enforceSingleRequest:  true,
+
+		pods:      make(map[string]string),
+		endpoints: make(map[string]string),
+	}
+}
+
+// MapEndpointIP mocks the corresponding IPAMClient function.
+func (mock *IPAMClient) MapEndpointIP(_ context.Context, req *ipam.MapRequest, _ ...grpc.CallOption) (*ipam.MapResponse, error) {
+	// Check first if the translation has already been computed.
+	if translation, found := mock.endpoints[req.GetIp()]; found {
+		if mock.enforceSingleRequest {
+			return nil, fmt.Errorf("mapping for IP %v already requested", req.GetIp())
+		}
+		return &ipam.MapResponse{Ip: translation}, nil
+	}
+
+	ip, err := utils.MapIPToNetwork(mock.localRemappedPodCIDR, req.GetIp())
+	if err != nil {
+		return nil, err
+	}
+	mock.endpoints[req.GetIp()] = ip
+	return &ipam.MapResponse{Ip: ip}, nil
+}
+
+// UnmapEndpointIP mocks the corresponding IPAMClient function.
+func (mock *IPAMClient) UnmapEndpointIP(_ context.Context, req *ipam.UnmapRequest, _ ...grpc.CallOption) (*ipam.UnmapResponse, error) {
+	// Check first if the translation has already been removed.
+	if _, found := mock.endpoints[req.GetIp()]; !found && mock.enforceSingleRequest {
+		return nil, fmt.Errorf("unmapping for IP %v already requested", req.GetIp())
+	}
+	delete(mock.endpoints, req.GetIp())
+	return &ipam.UnmapResponse{}, nil
+}
+
+// IsEndpointTranslated returns whether the given endpoint has a valid translation.
+func (mock *IPAMClient) IsEndpointTranslated(ip string) bool {
+	_, found := mock.endpoints[ip]
+	return found
+}
+
+// GetHomePodIP mocks the corresponding IPAMClient function.
+func (mock *IPAMClient) GetHomePodIP(_ context.Context, req *ipam.GetHomePodIPRequest, _ ...grpc.CallOption) (*ipam.GetHomePodIPResponse, error) {
+	// Check first if the translation has already been computed.
+	if translation, found := mock.pods[req.GetIp()]; found {
+		if mock.enforceSingleRequest {
+			return nil, fmt.Errorf("mapping for IP %v already requested", req.GetIp())
+		}
+		return &ipam.GetHomePodIPResponse{HomeIP: translation}, nil
+	}
+
+	homeIP, err := utils.MapIPToNetwork(mock.remoteRemappedPodCIDR, req.GetIp())
+	if err != nil {
+		return nil, err
+	}
+	mock.pods[req.GetIp()] = homeIP
+	return &ipam.GetHomePodIPResponse{HomeIP: homeIP}, nil
+}

pkg/liqonet/test/ipam_mock.go

@@ -16,7 +16,6 @@ package apiReflection
 
 const (
 	Configmaps = iota
-	EndpointSlices
 	Pods
 	ReplicaSets
 	Secrets
@@ -25,11 +24,10 @@ const (
 type ApiType int
 
 var ApiNames = map[ApiType]string{
-	Configmaps:     "configmaps",
-	EndpointSlices: "endpointslices",
-	Pods:           "pods",
-	ReplicaSets:    "replicasets",
-	Secrets:        "secrets",
+	Configmaps:  "configmaps",
+	Pods:        "pods",
+	ReplicaSets: "replicasets",
+	Secrets:     "secrets",
 }
 
 type ApiEvent struct {

pkg/virtualKubelet/apiReflection/const.go

@@ -24,8 +24,5 @@ type blackListType map[string]struct{}
 // the blacklist is generally checked in the `isAllowed` method of the reflectors
 // TODO: in a future version we could/should move to a dynamic blaklisting package with contexts.
 var Blacklist = map[apimgmt.ApiType]blackListType{
-	apimgmt.EndpointSlices: {
-		"default/kubernetes": struct{}{},
-	},
 	apimgmt.Pods: {},
 }

pkg/virtualKubelet/apiReflection/reflectors/blacklists.go

@@ -15,45 +15,20 @@
 package outgoing
 
 import (
-	"fmt"
-
-	"google.golang.org/grpc"
-	"k8s.io/klog/v2"
-
-	liqoconst "github.com/liqotech/liqo/pkg/consts"
-	liqonetIpam "github.com/liqotech/liqo/pkg/liqonet/ipam"
 	apimgmt "github.com/liqotech/liqo/pkg/virtualKubelet/apiReflection"
 	ri "github.com/liqotech/liqo/pkg/virtualKubelet/apiReflection/reflectors/reflectorsInterfaces"
 	"github.com/liqotech/liqo/pkg/virtualKubelet/options"
-	"github.com/liqotech/liqo/pkg/virtualKubelet/options/types"
 )
 
 var ReflectorBuilders = map[apimgmt.ApiType]func(reflector ri.APIReflector, opts map[options.OptionKey]options.Option) ri.OutgoingAPIReflector{
-	apimgmt.Configmaps:     configmapsReflectorBuilder,
-	apimgmt.EndpointSlices: endpointslicesReflectorBuilder,
-	apimgmt.Secrets:        secretsReflectorBuilder,
+	apimgmt.Configmaps: configmapsReflectorBuilder,
+	apimgmt.Secrets:    secretsReflectorBuilder,
 }
 
 func configmapsReflectorBuilder(reflector ri.APIReflector, _ map[options.OptionKey]options.Option) ri.OutgoingAPIReflector {
 	return &ConfigmapsReflector{APIReflector: reflector}
 }
 
-func endpointslicesReflectorBuilder(reflector ri.APIReflector, opts map[options.OptionKey]options.Option) ri.OutgoingAPIReflector {
-	conn, err := grpc.Dial(fmt.Sprintf("%s:%d", opts[options.OptionKey(types.LiqoIpamServer)].Value(), liqoconst.NetworkManagerIpamPort),
-		grpc.WithInsecure(),
-		grpc.WithBlock())
-	if err != nil {
-		klog.Error(err)
-	}
-	ipamClient := liqonetIpam.NewIpamClient(conn)
-
-	return &EndpointSlicesReflector{
-		APIReflector:    reflector,
-		VirtualNodeName: opts[types.VirtualNodeName],
-		IpamClient:      ipamClient,
-	}
-}
-
 func secretsReflectorBuilder(reflector ri.APIReflector, _ map[options.OptionKey]options.Option) ri.OutgoingAPIReflector {
 	return &SecretsReflector{APIReflector: reflector}
 }