From 169a1e9602a67b0eacc5b6b3e8db5b031851c27a Mon Sep 17 00:00:00 2001 From: Alejandro Mery Date: Mon, 3 Jun 2024 13:56:38 +0000 Subject: [PATCH 1/3] rings: introduce RingID and its values Signed-off-by: Alejandro Mery --- pkg/rings/rings.go | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/pkg/rings/rings.go b/pkg/rings/rings.go index 9626120..ae75e1e 100644 --- a/pkg/rings/rings.go +++ b/pkg/rings/rings.go @@ -11,6 +11,17 @@ import ( ) const ( + // UnspecifiedRingID is the zero value of RingID and not considered + // valid. + UnspecifiedRingID RingID = iota + RingZeroID // RingZeroID is the RingID for RingZero (backbone) + RingOneID // RingOneID is the RingID for RingOne (local zone) + RingTwoID // RingTwoID is the RingID for RingTwo (region services) + RingThreeID // RingThreeID is the RingID for RingThree (region cluster pods) + + // RingMax indicates the highest [Ring] identifier + RingMax = RingThreeID + // RegionMax indicates the highest number that can be used for a [RegionID]. RegionMax = (1 << 4) - 1 // ZoneMax indicates the highest number that can be used for a [ZoneID]. @@ -33,6 +44,21 @@ const ( RingThreeBits = 12 ) +// RingID identifies a Ring +type RingID int + +// Valid tells a [RingID] is within the valid range. +func (n RingID) Valid() bool { return n > 0 && n <= RingMax } + +func (n RingID) String() string { + return idString(n) +} + +// A Ring identifies what ring an address belongs to +type Ring interface { + ID() RingID +} + // RegionID is the identifier of a region, valid between 1 and [RegionMax]. type RegionID int From 96c59dfe8a61345434db066d5fd1d04a0d54465c Mon Sep 17 00:00:00 2001 From: Alejandro Mery Date: Mon, 3 Jun 2024 14:17:35 +0000 Subject: [PATCH 2/3] rings: introduce a generic DecodeAddress() for all four rings Signed-off-by: Alejandro Mery --- pkg/rings/decode.go | 74 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 pkg/rings/decode.go diff --git a/pkg/rings/decode.go b/pkg/rings/decode.go new file mode 100644 index 0000000..45c17cb --- /dev/null +++ b/pkg/rings/decode.go @@ -0,0 +1,74 @@ +package rings + +import ( + "net/netip" +) + +// DecodeAddress extracts ring address fields from a given 10.0.0.0/8 +// address. +// +// revive:disable:function-result-limit +func DecodeAddress[T ~uint | NodeID](addr netip.Addr) (RingID, RegionID, ZoneID, T) { + // revive:enable:function-result-limit + if addr.IsValid() { + if addr.Is4In6() { + addr = addr.Unmap() + } + + if addr.Is4() { + a4 := addr.As4() + return unsafeDecodeAddress[T](a4[0], a4[1], a4[2], a4[3]) + } + } + + return UnspecifiedRingID, 0, 0, 0 +} + +// revive:disable:function-result-limit +func unsafeDecodeAddress[T ~uint | NodeID](a, b, c, d byte) (RingID, RegionID, ZoneID, T) { + // revive:enable:function-result-limit + switch { + case a != 10: + return UnspecifiedRingID, 0, 0, 0 + case b == 0x00: + // 10.00.RZ.dd + k := RingZeroID + r := RegionID(c >> 4) + z := ZoneID(c & 0xf) + n := T(d) + + return k, r, z, n + case b&0xf0 != 0: + // 10.Rb.cc.dd + k := RingThreeID + r := RegionID(b >> 4) + + n2 := T(b & 0x0f) + n1 := T(c) + n0 := T(d) + n := n0 + n1<<8 + n2<<16 + + return k, r, 0, n + case c&0xf0 != 0: + // 10.0R.Zc.dd + k := RingOneID + r := RegionID(b) + z := ZoneID(c >> 4) + + n1 := T(c & 0x0f) + n0 := T(d) + n := n0 + n1<<8 + + return k, r, z, n + default: + // 10.0R.0c.dd + k := RingTwoID + r := RegionID(b) + + n1 := T(c & 0x0f) + n0 := T(d) + n := n0 + n1<<8 + + return k, r, 0, n + } +} From bcb20ab1e6f948b671d6312b54b262d59f8c672d Mon Sep 17 00:00:00 2001 From: Alejandro Mery Date: Mon, 3 Jun 2024 14:26:27 +0000 Subject: [PATCH 3/3] rings: introduce ring-specific decoders Signed-off-by: Alejandro Mery --- pkg/rings/decode.go | 48 ++++++++++++++++++++++++++++++++++++ pkg/rings/decode_test.go | 53 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 pkg/rings/decode_test.go diff --git a/pkg/rings/decode.go b/pkg/rings/decode.go index 45c17cb..a725531 100644 --- a/pkg/rings/decode.go +++ b/pkg/rings/decode.go @@ -72,3 +72,51 @@ func unsafeDecodeAddress[T ~uint | NodeID](a, b, c, d byte) (RingID, RegionID, Z return k, r, 0, n } } + +// DecodeRingZeroAddress attempts to extract region, zone and node identifiers +// from a given ring 0 address. +// +// revive:disable:function-result-limit +func DecodeRingZeroAddress(addr netip.Addr) (RegionID, ZoneID, NodeID, bool) { + // revive:enable:function-result-limit + k, r, z, n := DecodeAddress[NodeID](addr) + if k == RingZeroID { + return r, z, n, true + } + + return 0, 0, 0, false +} + +// DecodeRingOneAddress attempts to extract region, zone and node identifiers +// from a given ring 1 address. +// +// revive:disable:function-result-limit +func DecodeRingOneAddress(addr netip.Addr) (RegionID, ZoneID, NodeID, bool) { + // revive:enable:function-result-limit + k, r, z, n := DecodeAddress[NodeID](addr) + if k == RingOneID { + return r, z, n, true + } + + return 0, 0, 0, false +} + +// DecodeRingTwoAddress attempts to extract region and unique identifier for +// a kubernetes service from a given ring 2 address. +func DecodeRingTwoAddress(addr netip.Addr) (RegionID, uint, bool) { + k, r, _, n := DecodeAddress[uint](addr) + if k == RingTwoID { + return r, n, true + } + return 0, 0, false +} + +// DecodeRingThreeAddress attempts to extract region and unique identifier for +// a kubernetes pod from a given ring 3 address. +func DecodeRingThreeAddress(addr netip.Addr) (RegionID, uint, bool) { + k, r, _, n := DecodeAddress[uint](addr) + if k == RingThreeID { + return r, n, true + } + return 0, 0, false +} diff --git a/pkg/rings/decode_test.go b/pkg/rings/decode_test.go new file mode 100644 index 0000000..2dff604 --- /dev/null +++ b/pkg/rings/decode_test.go @@ -0,0 +1,53 @@ +package rings + +import ( + "fmt" + "net/netip" + "testing" +) + +func TestDecodeRingZeroAddress(t *testing.T) { + RZNDecodeTest(t, "DecodeRingZeroAddress", DecodeRingZeroAddress, []RZNDecodeTestCase{ + {1, 1, 50, MustParseAddr("10.0.17.50"), true}, + {1, 2, 50, MustParseAddr("10.0.18.50"), true}, + {2, 3, 1, MustParseAddr("10.0.35.1"), true}, + }) +} + +func TesDecodetRingOneAddress(t *testing.T) { + RZNDecodeTest(t, "DecodeRingOneAddress", DecodeRingOneAddress, []RZNDecodeTestCase{ + {1, 1, 50, MustParseAddr("10.1.16.50"), true}, + {1, 2, 50, MustParseAddr("10.1.32.50"), true}, + {2, 3, 300, MustParseAddr("10.2.49.44"), true}, + }) +} + +type RZNDecodeTestCase struct { + region RegionID + zone ZoneID + node NodeID + addr netip.Addr + ok bool +} + +func RZNDecodeTest(t *testing.T, + fnName string, fn func(netip.Addr) (RegionID, ZoneID, NodeID, bool), + cases []RZNDecodeTestCase) { + // + for i, tc := range cases { + s := fmt.Sprintf("%s(%q)", fnName, tc.addr) + + r, z, n, ok := fn(tc.addr) + + switch { + case ok != tc.ok, r != tc.region, z != tc.zone, n != tc.node: + t.Errorf("ERROR: [%v/%v]: %s → %v %v %v %v (expected %v %v %v %v)", + i, len(cases), s, + r, z, n, ok, + tc.region, tc.zone, tc.node, tc.ok) + default: + t.Logf("[%v/%v]: %s → %v %v %v %v", i, len(cases), s, + r, z, n, ok) + } + } +}