Dualstack Network Support

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

@@ -20,6 +20,7 @@ type IPSearchQuery struct {
 	ProjectID        *string  `json:"projectid" description:"the project this ip address belongs to, empty if not strong coupled" optional:"true"`
 	Type             *string  `json:"type" description:"the type of the ip address, ephemeral or static" optional:"true"`
 	MachineID        *string  `json:"machineid" description:"the machine an ip address is associated to" optional:"true"`
+	AddressFamily    *string  `json:"addressfamily" optional:"true" enum:"IPv4|IPv6"`
 }
 
 // GenerateTerm generates the project search query term.
@@ -79,6 +80,21 @@ func (p *IPSearchQuery) generateTerm(rs *RethinkStore) *r.Term {
 		})
 	}
 
+	if p.AddressFamily != nil {
+		separator := "."
+		af := metal.ToAddressFamily(*p.AddressFamily)
+		switch af {
+		case metal.IPv4AddressFamily:
+			separator = "\\."
+		case metal.IPv6AddressFamily:
+			separator = ":"
+		}
+
+		q = q.Filter(func(row r.Term) r.Term {
+			return row.Field("id").Match(separator)
+		})
+	}
+
 	return &q
 }
 

cmd/metal-api/internal/datastore/migrations/08_childprefixlength.go

@@ -0,0 +1,90 @@
+package migrations
+
+import (
+	"net/netip"
+
+	r "gopkg.in/rethinkdb/rethinkdb-go.v6"
+
+	"github.com/metal-stack/metal-api/cmd/metal-api/internal/datastore"
+	"github.com/metal-stack/metal-api/cmd/metal-api/internal/metal"
+)
+
+func init() {
+	type tmpPartition struct {
+		PrivateNetworkPrefixLength uint8 `rethinkdb:"privatenetworkprefixlength"`
+	}
+	datastore.MustRegisterMigration(datastore.Migration{
+		Name:    "migrate partition.childprefixlength to tenant super network",
+		Version: 8,
+		Up: func(db *r.Term, session r.QueryExecutor, rs *datastore.RethinkStore) error {
+			nws, err := rs.ListNetworks()
+			if err != nil {
+				return err
+			}
+
+			for _, old := range nws {
+				cursor, err := db.Table("partition").Get(old.PartitionID).Run(session)
+				if err != nil {
+					return err
+				}
+				if cursor.IsNil() {
+					_ = cursor.Close()
+					continue
+				}
+				var partition tmpPartition
+				err = cursor.One(&partition)
+				if err != nil {
+					_ = cursor.Close()
+					return err
+				}
+				err = cursor.Close()
+				if err != nil {
+					return err
+				}
+				new := old
+
+				var (
+					af                       metal.AddressFamily
+					defaultChildPrefixLength = metal.ChildPrefixLength{}
+				)
+				// FIXME check all prefixes
+				parsed, err := netip.ParsePrefix(new.Prefixes[0].String())
+				if err != nil {
+					return err
+				}
+				if parsed.Addr().Is4() {
+					af = metal.IPv4AddressFamily
+					defaultChildPrefixLength[af] = 22
+				}
+				if parsed.Addr().Is6() {
+					af = metal.IPv6AddressFamily
+					defaultChildPrefixLength[af] = 64
+				}
+
+				if new.AddressFamilies == nil {
+					new.AddressFamilies = metal.AddressFamilies{}
+				}
+				new.AddressFamilies = metal.AddressFamilies{af}
+
+				if new.PrivateSuper {
+					if new.DefaultChildPrefixLength == nil {
+						new.DefaultChildPrefixLength = make(map[metal.AddressFamily]uint8)
+					}
+					if partition.PrivateNetworkPrefixLength > 0 {
+						new.DefaultChildPrefixLength[af] = partition.PrivateNetworkPrefixLength
+					} else {
+						new.DefaultChildPrefixLength = defaultChildPrefixLength
+					}
+
+				}
+				err = rs.UpdateNetwork(&old, &new)
+				if err != nil {
+					return err
+				}
+			}
+
+			_, err = db.Table("partition").Replace(r.Row.Without("privatenetworkprefixlength")).RunWrite(session)
+			return err
+		},
+	})
+}

cmd/metal-api/internal/datastore/migrations_integration/migrate_integration_test.go

@@ -31,7 +31,7 @@ func Test_Migration(t *testing.T) {
 		_ = container.Terminate(context.Background())
 	}()
 
-	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelError}))
+	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
 
 	rs := datastore.New(log, c.IP+":"+c.Port, c.DB, c.User, c.Password)
 	rs.VRFPoolRangeMin = 10000
@@ -191,3 +191,134 @@ func Test_Migration(t *testing.T) {
 	assert.Equal(t, ec.Events[0].Time.Unix(), lastEventTime.Unix())
 	assert.Equal(t, ec.Events[1].Time.Unix(), now.Unix())
 }
+
+func Test_MigrationChildPrefixLength(t *testing.T) {
+	type tmpPartition struct {
+		ID                         string `rethinkdb:"id"`
+		PrivateNetworkPrefixLength uint8  `rethinkdb:"privatenetworkprefixlength"`
+	}
+
+	container, c, err := test.StartRethink(t)
+	require.NoError(t, err)
+	defer func() {
+		_ = container.Terminate(context.Background())
+	}()
+
+	log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+
+	rs := datastore.New(log, c.IP+":"+c.Port, c.DB, c.User, c.Password)
+	// limit poolsize to speed up initialization
+	rs.VRFPoolRangeMin = 10000
+	rs.VRFPoolRangeMax = 10010
+	rs.ASNPoolRangeMin = 10000
+	rs.ASNPoolRangeMax = 10010
+
+	err = rs.Connect()
+	require.NoError(t, err)
+	err = rs.Initialize()
+	require.NoError(t, err)
+
+	var (
+		p1 = &tmpPartition{
+			ID:                         "p1",
+			PrivateNetworkPrefixLength: 22,
+		}
+		p2 = &tmpPartition{
+			ID:                         "p2",
+			PrivateNetworkPrefixLength: 24,
+		}
+		p3 = &tmpPartition{
+			ID: "p3",
+		}
+		n1 = &metal.Network{
+			Base: metal.Base{
+				ID: "n1",
+			},
+			PartitionID: "p1",
+			Prefixes: metal.Prefixes{
+				{IP: "10.0.0.0", Length: "8"},
+			},
+			PrivateSuper: true,
+		}
+		n2 = &metal.Network{
+			Base: metal.Base{
+				ID: "n2",
+			},
+			Prefixes: metal.Prefixes{
+				{IP: "2001::", Length: "64"},
+			},
+			PartitionID:  "p2",
+			PrivateSuper: true,
+		}
+		n3 = &metal.Network{
+			Base: metal.Base{
+				ID: "n3",
+			},
+			Prefixes: metal.Prefixes{
+				{IP: "100.1.0.0", Length: "22"},
+			},
+			PartitionID:  "p2",
+			PrivateSuper: false,
+		}
+		n4 = &metal.Network{
+			Base: metal.Base{
+				ID: "n4",
+			},
+			Prefixes: metal.Prefixes{
+				{IP: "100.1.0.0", Length: "22"},
+			},
+			PartitionID:  "p3",
+			PrivateSuper: true,
+		}
+	)
+	_, err = r.DB("metal").Table("partition").Insert(p1).RunWrite(rs.Session())
+	require.NoError(t, err)
+	_, err = r.DB("metal").Table("partition").Insert(p2).RunWrite(rs.Session())
+	require.NoError(t, err)
+	_, err = r.DB("metal").Table("partition").Insert(p3).RunWrite(rs.Session())
+	require.NoError(t, err)
+
+	err = rs.CreateNetwork(n1)
+	require.NoError(t, err)
+	err = rs.CreateNetwork(n2)
+	require.NoError(t, err)
+	err = rs.CreateNetwork(n3)
+	require.NoError(t, err)
+	err = rs.CreateNetwork(n4)
+	require.NoError(t, err)
+
+	err = rs.Migrate(nil, false)
+	require.NoError(t, err)
+
+	p, err := rs.FindPartition(p1.ID)
+	require.NoError(t, err)
+	require.NotNil(t, p)
+	p, err = rs.FindPartition(p2.ID)
+	require.NoError(t, err)
+	require.NotNil(t, p)
+
+	n1fetched, err := rs.FindNetworkByID(n1.ID)
+	require.NoError(t, err)
+	require.NotNil(t, n1fetched)
+	require.Equal(t, p1.PrivateNetworkPrefixLength, n1fetched.DefaultChildPrefixLength[metal.IPv4AddressFamily], "childprefixlength:%v", n1fetched.DefaultChildPrefixLength)
+	require.Contains(t, n1fetched.AddressFamilies, metal.IPv4AddressFamily)
+
+	n2fetched, err := rs.FindNetworkByID(n2.ID)
+	require.NoError(t, err)
+	require.NotNil(t, n2fetched)
+	require.Equal(t, p2.PrivateNetworkPrefixLength, n2fetched.DefaultChildPrefixLength[metal.IPv6AddressFamily], "childprefixlength:%v", n2fetched.DefaultChildPrefixLength)
+	require.Contains(t, n2fetched.AddressFamilies, metal.IPv6AddressFamily)
+
+	n3fetched, err := rs.FindNetworkByID(n3.ID)
+	require.NoError(t, err)
+	require.NotNil(t, n3fetched)
+	require.Nil(t, n3fetched.DefaultChildPrefixLength)
+	require.Contains(t, n3fetched.AddressFamilies, metal.IPv4AddressFamily)
+
+	n4fetched, err := rs.FindNetworkByID(n4.ID)
+	require.NoError(t, err)
+	require.NotNil(t, n4fetched)
+	require.NotNil(t, n4fetched.DefaultChildPrefixLength)
+	require.Contains(t, n4fetched.AddressFamilies, metal.IPv4AddressFamily)
+	require.Equal(t, uint8(22), n4fetched.DefaultChildPrefixLength[metal.IPv4AddressFamily])
+}

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

@@ -24,6 +24,7 @@ type NetworkSearchQuery struct {
 	Vrf                 *int64            `json:"vrf" optional:"true"`
 	ParentNetworkID     *string           `json:"parentnetworkid" optional:"true"`
 	Labels              map[string]string `json:"labels" optional:"true"`
+	AddressFamily       *string           `json:"addressfamily" optional:"true" enum:"IPv4|IPv6"`
 }
 
 func (p *NetworkSearchQuery) Validate() error {
@@ -154,6 +155,25 @@ func (p *NetworkSearchQuery) generateTerm(rs *RethinkStore) (*r.Term, error) {
 		})
 	}
 
+	if p.AddressFamily != nil {
+		separator := "."
+		af := metal.ToAddressFamily(*p.AddressFamily)
+		switch af {
+		case metal.IPv4AddressFamily:
+			separator = "\\."
+		case metal.IPv6AddressFamily:
+			separator = ":"
+		}
+
+		fmt.Printf("Separator:%s\n", separator)
+
+		q = q.Filter(func(row r.Term) r.Term {
+			return row.Field("prefixes").Contains(func(p r.Term) r.Term {
+				return p.Field("ip").Match(separator)
+			})
+		})
+	}
+
 	return &q, nil
 }
 

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

@@ -68,6 +68,9 @@ func (_ *networkTestable) defaultBody(n *metal.Network) *metal.Network {
 	if n.AdditionalAnnouncableCIDRs == nil {
 		n.AdditionalAnnouncableCIDRs = []string{}
 	}
+	if n.AddressFamilies == nil {
+		n.AddressFamilies = metal.AddressFamilies{}
+	}
 	return n
 }
 
@@ -301,6 +304,34 @@ func TestRethinkStore_SearchNetworks(t *testing.T) {
 			},
 			wantErr: nil,
 		},
+		{
+			name: "search by ipv4 addressfamily",
+			q: &NetworkSearchQuery{
+				AddressFamily: pointer.Pointer(string(metal.IPv4AddressFamily)),
+			},
+			mock: []*metal.Network{
+				{Base: metal.Base{ID: "1"}, Prefixes: metal.Prefixes{{IP: "1.2.3.4", Length: "32"}}},
+				{Base: metal.Base{ID: "2"}, Prefixes: metal.Prefixes{{IP: "fe80::", Length: "64"}}},
+			},
+			want: []*metal.Network{
+				tt.defaultBody(&metal.Network{Base: metal.Base{ID: "1"}, Prefixes: metal.Prefixes{{IP: "1.2.3.4", Length: "32"}}}),
+			},
+			wantErr: nil,
+		},
+		{
+			name: "search by ipv6 addressfamily",
+			q: &NetworkSearchQuery{
+				AddressFamily: pointer.Pointer(string(metal.IPv6AddressFamily)),
+			},
+			mock: []*metal.Network{
+				{Base: metal.Base{ID: "1"}, Prefixes: metal.Prefixes{{IP: "1.2.3.4", Length: "32"}}},
+				{Base: metal.Base{ID: "2"}, Prefixes: metal.Prefixes{{IP: "fe80::", Length: "64"}}},
+			},
+			want: []*metal.Network{
+				tt.defaultBody(&metal.Network{Base: metal.Base{ID: "2"}, Prefixes: metal.Prefixes{{IP: "fe80::", Length: "64"}}}),
+			},
+			wantErr: nil,
+		},
 	}
 
 	for i := range tests {

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

@@ -384,7 +384,7 @@ func (rs *RethinkStore) findEntity(query *r.Term, entity interface{}) error {
 	}
 	defer res.Close()
 	if res.IsNil() {
-		return metal.NotFound("no %v with found", getEntityName(entity))
+		return metal.NotFound("no %v found", getEntityName(entity))
 	}
 
 	hasResult := res.Next(entity)