Migrate ipam to use the grpc service

.github/workflows/docker.yaml

@@ -38,7 +38,7 @@ jobs:
         cache: false
 
     - name: Lint
-      uses: golangci/golangci-lint-action@v4
+      uses: golangci/golangci-lint-action@v6
       with:
         args: --build-tags integration -p bugs -p unused -D protogetter --timeout=5m
 

.github/workflows/release-drafter.yaml

@@ -10,6 +10,6 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: release-drafter/release-drafter@v5
+    - uses: release-drafter/release-drafter@v6
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

cmd/metal-api/internal/datastore/network.go

@@ -1,10 +1,10 @@
 package datastore
 
 import (
+	"net/netip"
 	"strconv"
 
 	"github.com/metal-stack/metal-api/cmd/metal-api/internal/metal"
-	"github.com/metal-stack/metal-api/cmd/metal-api/internal/utils"
 	r "gopkg.in/rethinkdb/rethinkdb-go.v6"
 )
 
@@ -91,39 +91,45 @@ func (p *NetworkSearchQuery) generateTerm(rs *RethinkStore) *r.Term {
 	}
 
 	for _, prefix := range p.Prefixes {
-		ip, length := utils.SplitCIDR(prefix)
+		pfx, err := netip.ParsePrefix(prefix)
+		if err != nil {
+			continue
+		}
+		ip := pfx.Addr()
+		length := pfx.Bits()
 
 		q = q.Filter(func(row r.Term) r.Term {
 			return row.Field("prefixes").Map(func(p r.Term) r.Term {
 				return p.Field("ip")
 			}).Contains(r.Expr(ip))
 		})
 
-		if length != nil {
-			q = q.Filter(func(row r.Term) r.Term {
-				return row.Field("prefixes").Map(func(p r.Term) r.Term {
-					return p.Field("length")
-				}).Contains(r.Expr(strconv.Itoa(*length)))
-			})
-		}
+		q = q.Filter(func(row r.Term) r.Term {
+			return row.Field("prefixes").Map(func(p r.Term) r.Term {
+				return p.Field("length")
+			}).Contains(r.Expr(strconv.Itoa(length)))
+		})
 	}
 
 	for _, destPrefix := range p.DestinationPrefixes {
-		ip, length := utils.SplitCIDR(destPrefix)
+		pfx, err := netip.ParsePrefix(destPrefix)
+		if err != nil {
+			continue
+		}
+		ip := pfx.Addr()
+		length := pfx.Bits()
 
 		q = q.Filter(func(row r.Term) r.Term {
 			return row.Field("destinationprefixes").Map(func(dp r.Term) r.Term {
 				return dp.Field("ip")
 			}).Contains(r.Expr(ip))
 		})
 
-		if length != nil {
-			q = q.Filter(func(row r.Term) r.Term {
-				return row.Field("destinationprefixes").Map(func(dp r.Term) r.Term {
-					return dp.Field("length")
-				}).Contains(r.Expr(strconv.Itoa(*length)))
-			})
-		}
+		q = q.Filter(func(row r.Term) r.Term {
+			return row.Field("destinationprefixes").Map(func(dp r.Term) r.Term {
+				return dp.Field("length")
+			}).Contains(r.Expr(strconv.Itoa(length)))
+		})
 	}
 
 	return &q

cmd/metal-api/internal/ipam/ipam.go

@@ -1,39 +1,59 @@
 package ipam
 
 import (
+	"context"
 	"fmt"
-	"net/netip"
 
 	"github.com/metal-stack/metal-api/cmd/metal-api/internal/metal"
+	"github.com/metal-stack/metal-lib/rest"
 
-	ipam "github.com/metal-stack/go-ipam"
+	"connectrpc.com/connect"
+	goipam "github.com/metal-stack/go-ipam"
+	apiv1 "github.com/metal-stack/go-ipam/api/v1"
+
+	"github.com/metal-stack/go-ipam/api/v1/apiv1connect"
 )
 
-type Ipam struct {
-	ip ipam.Ipamer
+// A IPAMer is responsible to allocate a IP for a given purpose
+// On the other hand it should release the IP.
+// Later Implementations should also allocate and release Networks.
+type IPAMer interface {
+	AllocateIP(ctx context.Context, prefix metal.Prefix) (string, error)
+	AllocateSpecificIP(ctx context.Context, prefix metal.Prefix, specificIP string) (string, error)
+	ReleaseIP(ctx context.Context, ip metal.IP) error
+	AllocateChildPrefix(ctx context.Context, parentPrefix metal.Prefix, childLength uint8) (*metal.Prefix, error)
+	ReleaseChildPrefix(ctx context.Context, childPrefix metal.Prefix) error
+	CreatePrefix(ctx context.Context, prefix metal.Prefix) error
+	DeletePrefix(ctx context.Context, prefix metal.Prefix) error
+	PrefixUsage(ctx context.Context, cidr string) (*metal.NetworkUsage, error)
+	PrefixesOverlapping(existingPrefixes metal.Prefixes, newPrefixes metal.Prefixes) error
+	// Required for healthcheck
+	Check(ctx context.Context) (rest.HealthResult, error)
+	ServiceName() string
+}
+
+type ipam struct {
+	ip apiv1connect.IpamServiceClient
 }
 
 // New creates a new IPAM module.
-func New(ip ipam.Ipamer) *Ipam {
-	return &Ipam{
+func New(ip apiv1connect.IpamServiceClient) IPAMer {
+	return &ipam{
 		ip: ip,
 	}
 }
 
 // AllocateChildPrefix creates a child prefix from a parent prefix in the IPAM.
-func (i *Ipam) AllocateChildPrefix(parentPrefix metal.Prefix, childLength uint8) (*metal.Prefix, error) {
-	ipamParentPrefix := i.ip.PrefixFrom(parentPrefix.String())
-
-	if ipamParentPrefix == nil {
-		return nil, fmt.Errorf("error finding parent prefix in ipam: %s", parentPrefix.String())
-	}
-
-	ipamPrefix, err := i.ip.AcquireChildPrefix(ipamParentPrefix.Cidr, childLength)
+func (i *ipam) AllocateChildPrefix(ctx context.Context, parentPrefix metal.Prefix, childLength uint8) (*metal.Prefix, error) {
+	ipamPrefix, err := i.ip.AcquireChildPrefix(ctx, connect.NewRequest(&apiv1.AcquireChildPrefixRequest{
+		Cidr:   parentPrefix.String(),
+		Length: uint32(childLength),
+	}))
 	if err != nil {
 		return nil, fmt.Errorf("error creating new prefix in ipam: %w", err)
 	}
 
-	prefix, err := metal.NewPrefixFromCIDR(ipamPrefix.Cidr)
+	prefix, err := metal.NewPrefixFromCIDR(ipamPrefix.Msg.Prefix.Cidr)
 	if err != nil {
 		return nil, fmt.Errorf("error creating prefix from ipam prefix: %w", err)
 	}
@@ -42,21 +62,10 @@ func (i *Ipam) AllocateChildPrefix(parentPrefix metal.Prefix, childLength uint8)
 }
 
 // ReleaseChildPrefix release a child prefix from a parent prefix in the IPAM.
-func (i *Ipam) ReleaseChildPrefix(childPrefix metal.Prefix) error {
-	_, err := netip.ParsePrefix(childPrefix.String())
-	if err != nil {
-		return fmt.Errorf("invalid child prefix: %w", err)
-	}
-
-	ipamChildPrefix := i.ip.PrefixFrom(childPrefix.String())
-	if ipamChildPrefix == nil {
-		// FIXME: unfortunately, go-ipam does not return a proper error here so we cannot deduce if the prefix
-		// was already deleted or not, so if the database is down or something we continue with network deletion
-		// even though there could be remainings in the go-ipam db
-		return nil
-	}
-
-	err = i.ip.ReleaseChildPrefix(ipamChildPrefix)
+func (i *ipam) ReleaseChildPrefix(ctx context.Context, childPrefix metal.Prefix) error {
+	_, err := i.ip.ReleaseChildPrefix(ctx, connect.NewRequest(&apiv1.ReleaseChildPrefixRequest{
+		Cidr: childPrefix.String(),
+	}))
 	if err != nil {
 		return fmt.Errorf("error releasing child prefix in ipam: %w", err)
 	}
@@ -65,90 +74,110 @@ func (i *Ipam) ReleaseChildPrefix(childPrefix metal.Prefix) error {
 }
 
 // CreatePrefix creates a prefix in the IPAM.
-func (i *Ipam) CreatePrefix(prefix metal.Prefix) error {
-	_, err := i.ip.NewPrefix(prefix.String())
+func (i *ipam) CreatePrefix(ctx context.Context, prefix metal.Prefix) error {
+	_, err := i.ip.CreatePrefix(ctx, connect.NewRequest(&apiv1.CreatePrefixRequest{
+		Cidr: prefix.String(),
+	}))
 	if err != nil {
 		return fmt.Errorf("unable to create prefix in ipam: %w", err)
 	}
 	return nil
 }
 
 // DeletePrefix remove a prefix in the IPAM.
-func (i *Ipam) DeletePrefix(prefix metal.Prefix) error {
-	_, err := i.ip.DeletePrefix(prefix.String())
+func (i *ipam) DeletePrefix(ctx context.Context, prefix metal.Prefix) error {
+	_, err := i.ip.DeletePrefix(ctx, connect.NewRequest(&apiv1.DeletePrefixRequest{
+		Cidr: prefix.String(),
+	}))
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
 // AllocateIP an ip in the IPAM and returns the allocated IP as a string.
-func (i *Ipam) AllocateIP(prefix metal.Prefix) (string, error) {
-	ipamPrefix := i.ip.PrefixFrom(prefix.String())
-	if ipamPrefix == nil {
-		return "", fmt.Errorf("error finding prefix in ipam: %s", prefix.String())
-	}
-
-	ipamIP, err := i.ip.AcquireIP(ipamPrefix.Cidr)
+func (i *ipam) AllocateIP(ctx context.Context, prefix metal.Prefix) (string, error) {
+	ipamIP, err := i.ip.AcquireIP(ctx, connect.NewRequest(&apiv1.AcquireIPRequest{
+		PrefixCidr: prefix.String(),
+		Ip:         nil,
+	}))
 	if err != nil {
 		return "", fmt.Errorf("cannot allocate ip in prefix %s in ipam: %w", prefix.String(), err)
 	}
 	if ipamIP == nil {
 		return "", fmt.Errorf("cannot find free ip to allocate in ipam: %s", prefix.String())
 	}
 
-	return ipamIP.IP.String(), nil
+	return ipamIP.Msg.Ip.Ip, nil
 }
 
 // AllocateSpecificIP a specific ip in the IPAM and returns the allocated IP as a string.
-func (i *Ipam) AllocateSpecificIP(prefix metal.Prefix, specificIP string) (string, error) {
-	ipamPrefix := i.ip.PrefixFrom(prefix.String())
-	if ipamPrefix == nil {
-		return "", fmt.Errorf("error finding prefix in ipam: %s", prefix.String())
-	}
-	ipamIP, err := i.ip.AcquireSpecificIP(ipamPrefix.Cidr, specificIP)
+func (i *ipam) AllocateSpecificIP(ctx context.Context, prefix metal.Prefix, specificIP string) (string, error) {
+	ipamIP, err := i.ip.AcquireIP(ctx, connect.NewRequest(&apiv1.AcquireIPRequest{
+		PrefixCidr: prefix.String(),
+		Ip:         &specificIP,
+	}))
 	if err != nil {
 		return "", fmt.Errorf("cannot allocate ip in prefix %s in ipam: %w", prefix.String(), err)
 	}
 	if ipamIP == nil {
 		return "", fmt.Errorf("cannot find free ip to allocate in ipam: %s", prefix.String())
 	}
 
-	return ipamIP.IP.String(), nil
+	return ipamIP.Msg.Ip.Ip, nil
 }
 
 // ReleaseIP an ip in the IPAM.
-func (i *Ipam) ReleaseIP(ip metal.IP) error {
-	ipamPrefix := i.ip.PrefixFrom(ip.ParentPrefixCidr)
-	if ipamPrefix == nil {
-		return fmt.Errorf("error finding parent prefix %s of ip %s in ipam", ip.ParentPrefixCidr, ip.IPAddress)
-	}
-
-	err := i.ip.ReleaseIPFromPrefix(ipamPrefix.Cidr, ip.IPAddress)
+func (i *ipam) ReleaseIP(ctx context.Context, ip metal.IP) error {
+	_, err := i.ip.ReleaseIP(ctx, connect.NewRequest(&apiv1.ReleaseIPRequest{
+		PrefixCidr: ip.ParentPrefixCidr,
+		Ip:         ip.IPAddress,
+	}))
 	if err != nil {
 		return fmt.Errorf("error release ip %s in prefix %s: %w", ip.IPAddress, ip.ParentPrefixCidr, err)
 	}
 	return nil
 }
 
 // PrefixUsage calculates the IP and Prefix Usage
-func (i *Ipam) PrefixUsage(cidr string) (*metal.NetworkUsage, error) {
-	prefix := i.ip.PrefixFrom(cidr)
-	if prefix == nil {
-		return nil, fmt.Errorf("prefix for cidr:%s not found", cidr)
+func (i *ipam) PrefixUsage(ctx context.Context, cidr string) (*metal.NetworkUsage, error) {
+	usage, err := i.ip.PrefixUsage(ctx, connect.NewRequest(&apiv1.PrefixUsageRequest{
+		Cidr: cidr,
+	}))
+	if err != nil {
+		return nil, fmt.Errorf("prefix usage for cidr:%s not found %w", cidr, err)
 	}
-	usage := prefix.Usage()
 
 	return &metal.NetworkUsage{
-		AvailableIPs: usage.AvailableIPs,
-		UsedIPs:      usage.AcquiredIPs,
-		// FIXME add usage.AvailablePrefixList as already done here https://github.com/metal-stack/metal-api/pull/152/files#diff-fe05f7f1480be933b5c482b74af28c8b9ca7ef2591f8341eb6e6663cbaeda7baR828
-		AvailablePrefixes: usage.AvailableSmallestPrefixes,
-		UsedPrefixes:      usage.AcquiredPrefixes,
+		AvailableIPs: usage.Msg.AvailableIps,
+		UsedIPs:      usage.Msg.AcquiredIps,
+		// FIXME add usage.AvailablePrefixList as already done here
+		// https://github.com/metal-stack/metal-api/pull/152/files#diff-fe05f7f1480be933b5c482b74af28c8b9ca7ef2591f8341eb6e6663cbaeda7baR828
+		AvailablePrefixes: usage.Msg.AvailableSmallestPrefixes,
+		UsedPrefixes:      usage.Msg.AcquiredPrefixes,
 	}, nil
 }
 
 // PrefixesOverlapping returns an error if prefixes overlap.
-func (i *Ipam) PrefixesOverlapping(existingPrefixes metal.Prefixes, newPrefixes metal.Prefixes) error {
-	return i.ip.PrefixesOverlapping(existingPrefixes.String(), newPrefixes.String())
+func (i *ipam) PrefixesOverlapping(existingPrefixes metal.Prefixes, newPrefixes metal.Prefixes) error {
+	return goipam.PrefixesOverlapping(existingPrefixes.String(), newPrefixes.String())
+}
+
+func (i *ipam) ServiceName() string {
+	return "ipam"
+}
+
+func (i *ipam) Check(ctx context.Context) (rest.HealthResult, error) {
+	resp, err := i.ip.Version(ctx, connect.NewRequest(&apiv1.VersionRequest{}))
+
+	if err != nil {
+		return rest.HealthResult{
+			Status: rest.HealthStatusUnhealthy,
+		}, err
+	}
+
+	return rest.HealthResult{
+		Status:  rest.HealthStatusHealthy,
+		Message: fmt.Sprintf("connected to ipam service version:%q", resp.Msg.Version),
+	}, nil
 }

cmd/metal-api/internal/ipam/testing.go

@@ -1,13 +1,33 @@
 package ipam
 
 import (
+	"context"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	goipam "github.com/metal-stack/go-ipam"
+	"github.com/metal-stack/go-ipam/api/v1/apiv1connect"
+	"github.com/metal-stack/go-ipam/pkg/service"
 )
 
-func InitTestIpam(t *testing.T) *Ipam {
-	ipamInstance := goipam.New()
-	ipamer := New(ipamInstance)
+func InitTestIpam(t *testing.T) IPAMer {
+
+	ctx := context.Background()
+	mux := http.NewServeMux()
+	mux.Handle(apiv1connect.NewIpamServiceHandler(
+		service.New(slog.Default(), goipam.New(ctx)),
+	))
+	server := httptest.NewUnstartedServer(mux)
+	server.EnableHTTP2 = true
+	server.StartTLS()
+
+	ipamclient := apiv1connect.NewIpamServiceClient(
+		server.Client(),
+		server.URL,
+	)
+
+	ipamer := New(ipamclient)
 	return ipamer
 }