Use right half-open infinite intervals for routes

Author: bootjp

adapter/distribution_server.go

@@ -19,8 +19,8 @@ func NewDistributionServer(e *distribution.Engine) *DistributionServer {
 }
 
 // UpdateRoute allows updating route information.
-func (s *DistributionServer) UpdateRoute(start, end []byte, group uint64) {
-	s.engine.UpdateRoute(start, end, group)
+func (s *DistributionServer) UpdateRoute(start []byte, group uint64) {
+	s.engine.UpdateRoute(start, group)
 }
 
 // GetRoute returns route for a key.
@@ -31,7 +31,6 @@ func (s *DistributionServer) GetRoute(ctx context.Context, req *pb.GetRouteReque
 	}
 	return &pb.GetRouteResponse{
 		Start:       r.Start,
-		End:         r.End,
 		RaftGroupId: r.GroupID,
 	}, nil
 }

cmd/server/demo.go

@@ -93,7 +93,7 @@ func run(eg *errgroup.Group) error {
 		distEngine := distribution.NewEngine()
 		distSrv := adapter.NewDistributionServer(distEngine)
 		// example route for demo purposes
-		distSrv.UpdateRoute([]byte("a"), []byte("z"), uint64(i))
+		distSrv.UpdateRoute([]byte("a"), uint64(i))
 		tm.Register(s)
 		pb.RegisterRawKVServer(s, gs)
 		pb.RegisterTransactionalKVServer(s, gs)

distribution/engine.go

@@ -2,20 +2,19 @@ package distribution
 
 import (
 	"bytes"
+	"sort"
 	"sync"
 	"sync/atomic"
 )
 
-// Route represents mapping from key range to raft group.
-// The key range is half-open: [Start, End)
-// meaning Start is inclusive and End is exclusive. If End is nil or empty
-// the range is unbounded and covers all keys >= Start.
+// Route represents a mapping from a starting key to a raft group.
+// Ranges are right half-open infinite intervals: [Start, next Start).
+// Start is inclusive and the range extends up to (but excluding) the next
+// route's start. The last route is unbounded and covers all keys >= Start.
 type Route struct {
 	// Start marks the inclusive beginning of the range.
 	Start []byte
-        // End marks the exclusive end of the range. When empty, the range has
-        // no upper bound.
-        End     []byte
+	// GroupID identifies the raft group for the range starting at Start.
 	GroupID uint64
 }
 
@@ -31,27 +30,34 @@ func NewEngine() *Engine {
 	return &Engine{routes: make([]Route, 0)}
 }
 
-// UpdateRoute registers or updates a route. The range is [start, end). If end
-// is nil or empty the range is treated as unbounded above.
-func (e *Engine) UpdateRoute(start, end []byte, group uint64) {
+// UpdateRoute registers or updates a route starting at the given key.
+// Routes are stored sorted by Start.
+func (e *Engine) UpdateRoute(start []byte, group uint64) {
 	e.mu.Lock()
 	defer e.mu.Unlock()
-	e.routes = append(e.routes, Route{Start: start, End: end, GroupID: group})
+	e.routes = append(e.routes, Route{Start: start, GroupID: group})
+	sort.Slice(e.routes, func(i, j int) bool {
+		return bytes.Compare(e.routes[i].Start, e.routes[j].Start) < 0
+	})
 }
 
-// GetRoute finds a route for the given key. The search uses half-open ranges
-// [Start, End). If End is empty the range is treated as unbounded above.
+// GetRoute finds a route for the given key using right half-open infinite
+// intervals.
 func (e *Engine) GetRoute(key []byte) (Route, bool) {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
-        for _, r := range e.routes {
-                if bytes.Compare(key, r.Start) >= 0 {
-                        if len(r.End) == 0 || bytes.Compare(key, r.End) < 0 {
-                                return r, true
-                        }
-                }
-        }
-	return Route{}, false
+	if len(e.routes) == 0 {
+		return Route{}, false
+	}
+
+	// Find the first route with Start > key.
+	i := sort.Search(len(e.routes), func(i int) bool {
+		return bytes.Compare(e.routes[i].Start, key) > 0
+	})
+	if i == 0 {
+		return Route{}, false
+	}
+	return e.routes[i-1], true
 }
 
 // NextTimestamp returns a monotonic increasing timestamp.

distribution/engine_test.go

@@ -3,22 +3,22 @@ package distribution
 import "testing"
 
 func TestEngineRouteLookup(t *testing.T) {
-        e := NewEngine()
-        e.UpdateRoute([]byte("a"), []byte("m"), 1)
-        // second range has no upper bound
-        e.UpdateRoute([]byte("m"), nil, 2)
+	e := NewEngine()
+	e.UpdateRoute([]byte("a"), 1)
+	e.UpdateRoute([]byte("m"), 2)
 
 	cases := []struct {
 		key    []byte
 		group  uint64
 		expect bool
 	}{
-		{[]byte("a"), 1, true}, // start is inclusive
+		{[]byte("0"), 0, false}, // before first route
+		{[]byte("a"), 1, true},  // start is inclusive
 		{[]byte("b"), 1, true},
-                {[]byte("m"), 2, true}, // end is exclusive, so m belongs to second range
-                {[]byte("x"), 2, true},
-                {[]byte("za"), 2, true}, // unbounded range covers keys beyond z
-        }
+		{[]byte("m"), 2, true}, // next start marks new range
+		{[]byte("x"), 2, true},
+		{[]byte("za"), 2, true}, // last route is unbounded
+	}
 
 	for _, c := range cases {
 		r, ok := e.GetRoute(c.key)

proto/distribution.pb.go

@@ -12,11 +12,10 @@ message GetRouteRequest {
 }
 
 message GetRouteResponse {
-  // start is inclusive
+  // start is inclusive. The range extends up to (but excluding) the next
+  // route's start. If there is no subsequent start, the range is unbounded.
   bytes start = 1;
-  // end is exclusive. empty means the range is unbounded
-  bytes end = 2;
-  uint64 raft_group_id = 3;
+  uint64 raft_group_id = 2;
 }
 
 message GetTimestampRequest {}