1

diff --git a/README.md b/README.md
index a845dc6665d84b413a6dceb150ff7c3612dd464d..bb7d4d39f2806b2afb819f23f2da97dc5761a976 100755 (executable)
--- a/README.md
+++ b/README.md
@@ -29,6 +29,7 @@ config:
     - pathAdd: bool 将客户端访问的路径附加在path上 例：/api/req => /ws => /ws/api/req
     - rollRule: string 可选
         - `order`(按顺序)
+        - `loop`(轮流)
         - `disableC_MinFirst`(禁用数较少的优先)
         - `dealingC_MinFirst`(连接数较少的优先)
         - `chosenC_MinFirst`(被选择较少的优先)

diff --git a/config.go b/config.go
index 6b0cd58c7ca243d72f0c6ba11ae8ed7d4519566b..bb71c6b985f433e7aa3507e3f2334dbc79a97184 100755 (executable)
--- a/config.go
+++ b/config.go
@@ -146,7 +146,7 @@ func (t *Config) SwapSign(ctx context.Context, logger Logger) {
                                                }
 
                                                if aok {
-                                                       for i := 0; i < backP.(*Back).Weight; i++ {
+                                                       for i := uint(0); i < backP.(*Back).Weight; i++ {
                                                                backIs = append(backIs, backP.(*Back))
                                                        }
                                                }
@@ -292,6 +292,7 @@ func (t *Route) SwapSign(logger Logger) {
                        logger.Info(`I:`, fmt.Sprintf("%v > %v > %v", t.config.Addr, t.Path, t.Backs[i].Name))
                        t.backMap.Store(t.Backs[i].Id(), &t.Backs[i])
                }
+               t.Backs[i].index = i
                t.Backs[i].SwapSign(logger)
        }
 }
@@ -301,7 +302,7 @@ func (t *Route) FiliterBackByRequest(r *http.Request) []*Back {
        for i := 0; i < len(t.Backs); i++ {
                if ok, e := t.Backs[i].getFiliterReqHeader().Match(r.Header); ok && e == nil {
                        t.Backs[i].route = t
-                       for k := 0; k < t.Backs[i].Weight; k++ {
+                       for k := uint(0); k < t.Backs[i].Weight; k++ {
                                backLink = append(backLink, &t.Backs[i])
                        }
                }
@@ -317,17 +318,19 @@ func (t *Route) FiliterBackByRequest(r *http.Request) []*Back {
 }
 
 type Back struct {
-       route      *Route        `json:"-"`
-       lock       sync.RWMutex  `json:"-"`
-       upT        time.Time     `json:"-"`
-       disableC   int           `json:"-"`
-       dealingC   int           `json:"-"`
-       chosenC    int           `json:"-"`
+       route    *Route       `json:"-"`
+       lock     sync.RWMutex `json:"-"`
+       upT      time.Time    `json:"-"`
+       index    int          `json:"-"`
+       disableC uint         `json:"-"`
+       dealingC uint         `json:"-"`
+       chosenC  uint         `json:"-"`
+
        lastResDru time.Duration `json:"-"`
 
        Name     string `json:"name"`
        To       string `json:"to"`
-       Weight   int    `json:"weight"`
+       Weight   uint   `json:"weight"`
        AlwaysUp bool   `json:"alwaysUp"`
 
        Setting

diff --git a/rollRule.go b/rollRule.go
index 31acd8273a9d012296b3421d49c60534af175e89..c7b4642d6f52d466a89df600671e035e4443c9ba 100644 (file)
--- a/rollRule.go
+++ b/rollRule.go
@@ -12,19 +12,25 @@ func init() {
 
        rollRuleMap[`disable_MinFirst`] = func(backLink []*Back) {
                slices.SortStableFunc(backLink, func(a, b *Back) int {
-                       return a.disableC/(a.Weight+1) - b.disableC/(b.Weight+1)
+                       return int(a.disableC/(a.Weight+1) - b.disableC/(b.Weight+1))
                })
        }
 
        rollRuleMap[`dealingC_MinFirst`] = func(backLink []*Back) {
                slices.SortStableFunc(backLink, func(a, b *Back) int {
-                       return a.dealingC/(a.Weight+1) - b.dealingC/(b.Weight+1)
+                       return int(a.dealingC/(a.Weight+1) - b.dealingC/(b.Weight+1))
                })
        }
 
        rollRuleMap[`chosenC_MinFirst`] = func(backLink []*Back) {
                slices.SortStableFunc(backLink, func(a, b *Back) int {
-                       return a.chosenC/(a.Weight+1) - b.chosenC/(b.Weight+1)
+                       return int(a.chosenC/(a.Weight+1) - b.chosenC/(b.Weight+1))
+               })
+       }
+
+       rollRuleMap[`loop`] = func(backLink []*Back) {
+               slices.SortStableFunc(backLink, func(a, b *Back) int {
+                       return a.index - b.index
                })
        }
 }