mirror of https://github.com/rocboss/paopao-ce
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
121 lines
2.9 KiB
121 lines
2.9 KiB
// Copyright 2023 ROC. All rights reserved.
|
|
// Use of this source code is governed by a MIT style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package http
|
|
|
|
import (
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
var (
|
|
_ AsyncClient = (*wormClient)(nil)
|
|
)
|
|
|
|
const (
|
|
_minRequestInCh = 10
|
|
_minRequestInTmpCh = 10
|
|
_minWorker = 5
|
|
)
|
|
|
|
// ResponseFn a function used handle the response of http.Client.Do
|
|
type ResponseFn = func(req *http.Request, resp *http.Response, err error)
|
|
|
|
// AsyncClient asynchronous client interface
|
|
type AsyncClient interface {
|
|
Do(req *http.Request, fn ResponseFn)
|
|
}
|
|
|
|
// AsyncClientConf client configure used to create an AsynClient instance
|
|
type AsyncClientConf struct {
|
|
MinWorker int
|
|
MaxRequestInCh int
|
|
MaxRequestInTempCh int
|
|
MaxTickCount int
|
|
TickWaitTime time.Duration
|
|
}
|
|
|
|
type requestItem struct {
|
|
request *http.Request
|
|
fn ResponseFn
|
|
}
|
|
|
|
type wormClient struct {
|
|
client *http.Client
|
|
requestCh chan *requestItem // 正式工 缓存通道
|
|
requestTempCh chan *requestItem // 临时工 缓存通道
|
|
maxTickCount int
|
|
tickWaitTime time.Duration
|
|
}
|
|
|
|
func (s *wormClient) Do(req *http.Request, fn ResponseFn) {
|
|
item := &requestItem{req, fn}
|
|
select {
|
|
case s.requestCh <- item:
|
|
// send request item by requestCh chan
|
|
default:
|
|
select {
|
|
case s.requestTempCh <- item:
|
|
// send request item by requestTempCh chan"
|
|
default:
|
|
go func() {
|
|
s.do(item)
|
|
// watch requestTempCh to continue do work if needed.
|
|
// cancel loop if no item had watched in s.maxCyle * s.maxWaitTime.
|
|
for count := 0; count < s.maxTickCount; count++ {
|
|
select {
|
|
case item := <-s.requestTempCh:
|
|
// reset count to continue do work
|
|
count = 0
|
|
s.do(item)
|
|
default:
|
|
// sleeping to wait request item pass over to do work
|
|
time.Sleep(s.tickWaitTime)
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *wormClient) starDotWork() {
|
|
for item := range s.requestCh {
|
|
s.do(item)
|
|
}
|
|
}
|
|
|
|
func (s *wormClient) do(req *requestItem) {
|
|
resp, err := s.client.Do(req.request)
|
|
req.fn(req.request, resp, err)
|
|
}
|
|
|
|
// NewAsyncClient create an AsyncClient instance
|
|
func NewAsyncClient(client *http.Client, conf *AsyncClientConf) AsyncClient {
|
|
maxRequestInCh := _minRequestInCh
|
|
maxRequestInTempCh := _minRequestInTmpCh
|
|
if conf.MaxRequestInCh > _minRequestInCh {
|
|
maxRequestInCh = conf.MaxRequestInCh
|
|
}
|
|
if conf.MaxRequestInTempCh > _minRequestInTmpCh {
|
|
maxRequestInTempCh = conf.MaxRequestInTempCh
|
|
}
|
|
wc := &wormClient{
|
|
client: client,
|
|
requestCh: make(chan *requestItem, maxRequestInCh),
|
|
requestTempCh: make(chan *requestItem, maxRequestInTempCh),
|
|
}
|
|
numWorker := conf.MinWorker
|
|
if numWorker < _minWorker {
|
|
numWorker = _minWorker
|
|
}
|
|
logrus.Debugf("use %d backend worker to do the http request", numWorker)
|
|
// 启动 do work 正式工
|
|
for ; numWorker > 0; numWorker-- {
|
|
go wc.starDotWork()
|
|
}
|
|
return wc
|
|
}
|