feat: support set flowid range in allocator

Author: qingwusunny

ofctrl/cookie/allocator.go

@@ -1,6 +1,7 @@
 package cookie
 
 import (
+	"fmt"
 	"sync"
 )
 
@@ -10,8 +11,11 @@ const (
 	BitWidthFlowId          = 64 - BitWidthReserved - BitWidthRoundNum
 	RoundNumMask     uint64 = 0x0000_0000_f000_0000
 	FlowIdMask       uint64 = 0x0000_0000_0fff_ffff
+	InitFlowID       uint64 = 1
 )
 
+var FlowIDExhausted error = fmt.Errorf("flow id has exhausted")
+
 type ID uint64
 
 func newId(round uint64, flowId uint64) ID {
@@ -31,37 +35,71 @@ func (i ID) Round() uint64 {
 }
 
 type Allocator interface {
-	RequestCookie() uint64
+	RequestCookie() (uint64, error)
 	SetFixedMask(uint64)
 }
 
+type AllocatorOption func(*allocator) error
+
 type allocator struct {
 	roundNum   uint64
 	flowID     uint64
 	fixedMask  uint64
 	flowIDLock sync.RWMutex
+	maxFlowID  uint64
 }
 
 // cookie will 'OR' fixed mask
 func (a *allocator) SetFixedMask(mask uint64) {
 	a.fixedMask = mask
 }
 
-func (a *allocator) RequestCookie() uint64 {
+func (a *allocator) RequestCookie() (uint64, error) {
 	a.flowIDLock.Lock()
 	defer a.flowIDLock.Unlock()
 
+	if a.maxFlowID != 0 && a.flowID > a.maxFlowID {
+		return 0, FlowIDExhausted
+	}
 	rawID := newId(a.roundNum, a.flowID).RawId()
 	a.flowID += 1
-	return rawID | a.fixedMask
+	return rawID | a.fixedMask, nil
+}
+
+func (a *allocator) setFlowIDRange(start, end uint64) error {
+	if start > end {
+		return fmt.Errorf("param error, start %x can't bigger than end %x", start, end)
+	}
+	maxFlowIDOrigin := uint64(1<<BitWidthFlowId - 1)
+	minFlowID := InitFlowID
+	if start < minFlowID {
+		return fmt.Errorf("start %x can't small than minFlowID %x", start, minFlowID)
+	}
+	if end > maxFlowIDOrigin {
+		return fmt.Errorf("end %x can't biggger than maxFlowID %x", end, maxFlowIDOrigin)
+	}
+	a.flowID = start
+	a.maxFlowID = end
+	return nil
+}
+
+func SetFlowIDRange(start, end uint64) AllocatorOption {
+	return func(a *allocator) error {
+		return a.setFlowIDRange(start, end)
+	}
 }
 
-func NewAllocator(roundNum uint64) Allocator {
+func NewAllocator(roundNum uint64, options ...AllocatorOption) Allocator {
 	a := &allocator{
 		roundNum:   roundNum,
-		flowID:     1,
+		flowID:     InitFlowID,
 		flowIDLock: sync.RWMutex{},
 	}
+	for _, o := range options {
+		if err := o(a); err != nil {
+			return nil
+		}
+	}
 	return a
 }
 

ofctrl/cookie/allocator_test.go

@@ -7,39 +7,93 @@ import (
 func TestAllocateCookie(t *testing.T) {
 	allocator := NewAllocator(0)
 
-	cookie := allocator.RequestCookie()
+	cookie, err := allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x1 {
 		t.Errorf("request cookie fail, expect 0x1, got %x", cookie)
 	}
 
-	cookie = allocator.RequestCookie()
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x2 {
 		t.Errorf("request cookie fail, expect 0x2, got %x", cookie)
 	}
 
 	allocator.SetFixedMask(0x10)
 
-	cookie = allocator.RequestCookie()
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x13 {
 		t.Errorf("request cookie fail, expect 0x13, got %x", cookie)
 	}
 
 	allocator = NewAllocator(1)
 
-	cookie = allocator.RequestCookie()
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x10000001 {
 		t.Errorf("request cookie fail, expect 0x10000001, got %x", cookie)
 	}
 
-	cookie = allocator.RequestCookie()
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x10000002 {
 		t.Errorf("request cookie fail, expect 0x10000002, got %x", cookie)
 	}
 
 	allocator.SetFixedMask(0x100000000)
 
-	cookie = allocator.RequestCookie()
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
 	if cookie != 0x110000003 {
 		t.Errorf("request cookie fail, expect 0x110000003, got %x", cookie)
 	}
+
+	allocator = NewAllocator(1, SetFlowIDRange(10, 9))
+	if allocator != nil {
+		t.Errorf("expect allocator is nil, but real is not")
+	}
+
+	allocator = NewAllocator(1, SetFlowIDRange(0, 9))
+	if allocator != nil {
+		t.Errorf("expect allocator is nil, but real is not")
+	}
+
+	allocator = NewAllocator(1, SetFlowIDRange(10, 1<<BitWidthFlowId))
+	if allocator != nil {
+		t.Errorf("expect allocator is nil, but real is not")
+	}
+
+	allocator = NewAllocator(1, SetFlowIDRange(10, 11))
+
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
+	if cookie != 0x1000000a {
+		t.Errorf("request cookie fail, expect 0x1000000a , got %x", cookie)
+	}
+	cookie, err = allocator.RequestCookie()
+	if err != nil {
+		t.Errorf("unexpectd return err %s", err)
+	}
+	if cookie != 0x1000000b {
+		t.Errorf("request cookie fail, expect 0x1000000b, got %x", cookie)
+	}
+	cookie, err = allocator.RequestCookie()
+	if err == nil {
+		t.Errorf("expect allocate cookie failed, but success")
+	}
 }

ofctrl/fgraphTable.go

@@ -54,7 +54,11 @@ func (self *Table) NewFlow(match FlowMatch) (*Flow, error) {
 		return nil, dperror.NewDpError(dperror.SwitchDisconnectedError.Code, dperror.SwitchDisconnectedError.Msg, fmt.Errorf("ofSwitch disconnected"))
 	}
 	if self.Switch.CookieAllocator != nil {
-		flow.FlowID = self.Switch.CookieAllocator.RequestCookie()
+		var err error
+		flow.FlowID, err = self.Switch.CookieAllocator.RequestCookie()
+		if err != nil {
+			return nil, err
+		}
 	} else {
 		flow.FlowID = globalFlowID // FIXME: need a better id allocation
 		globalFlowID += 1