feat(dispenser): add worker-owned idle card prestaging
This commit is contained in:
@@ -23,9 +23,11 @@ const (
|
||||
)
|
||||
|
||||
type cmdReq struct {
|
||||
typ cmdType
|
||||
ctx context.Context
|
||||
respCh chan cmdResp
|
||||
passive bool
|
||||
generation uint64
|
||||
typ cmdType
|
||||
ctx context.Context
|
||||
respCh chan cmdResp
|
||||
}
|
||||
|
||||
type cmdResp struct {
|
||||
@@ -51,7 +53,10 @@ const (
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
port serialTransport
|
||||
activity activityGuard
|
||||
activityWake chan struct{}
|
||||
closeOnce sync.Once
|
||||
port serialTransport
|
||||
|
||||
reqCh chan cmdReq
|
||||
done chan struct{}
|
||||
@@ -80,9 +85,10 @@ func NewClient(port *serial.Port, queueSize int) *Client {
|
||||
queueSize = 16
|
||||
}
|
||||
c := &Client{
|
||||
port: port,
|
||||
reqCh: make(chan cmdReq, queueSize),
|
||||
done: make(chan struct{}),
|
||||
activityWake: make(chan struct{}, 1),
|
||||
port: port,
|
||||
reqCh: make(chan cmdReq, queueSize),
|
||||
done: make(chan struct{}),
|
||||
sequenceTiming: sequenceTiming{
|
||||
now: time.Now,
|
||||
wait: waitForSequence,
|
||||
@@ -106,12 +112,13 @@ func waitForSequence(ctx context.Context, duration time.Duration) error {
|
||||
}
|
||||
|
||||
func (c *Client) Close() {
|
||||
select {
|
||||
case <-c.done:
|
||||
return
|
||||
default:
|
||||
c.closeOnce.Do(func() {
|
||||
c.activity.Lock()
|
||||
c.activity.closed = true
|
||||
c.activity.Unlock()
|
||||
c.StopMaintenance()
|
||||
close(c.done)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// SetStatusTTL sets the duration for which cached status is considered fresh.
|
||||
@@ -150,7 +157,7 @@ func (c *Client) setStock(statusBytes []byte) {
|
||||
}
|
||||
|
||||
// StartPolling performs a periodic status refresh.
|
||||
// It will NOT interrupt commands: it enqueues only when queue is idle.
|
||||
// Passive requests are admitted by the worker only for the captured idle generation.
|
||||
func (c *Client) StartPolling(interval time.Duration) {
|
||||
if interval <= 0 {
|
||||
return
|
||||
@@ -168,8 +175,13 @@ func (c *Client) StartPolling(interval time.Duration) {
|
||||
if len(c.reqCh) != 0 {
|
||||
continue
|
||||
}
|
||||
generation, idle := c.passiveGeneration()
|
||||
if !idle {
|
||||
continue
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
_, err := c.CheckStatus(ctx)
|
||||
response := c.sendRequest(cmdReq{typ: cmdStatus, ctx: ctx, passive: true, generation: generation})
|
||||
err := response.err
|
||||
if err != nil {
|
||||
log.Debugf("dispenser polling: %v", err)
|
||||
}
|
||||
@@ -180,12 +192,28 @@ func (c *Client) StartPolling(interval time.Duration) {
|
||||
}
|
||||
|
||||
func (c *Client) loop() {
|
||||
timer := time.NewTimer(time.Hour)
|
||||
defer timer.Stop()
|
||||
for {
|
||||
if !timer.Stop() {
|
||||
select {
|
||||
case <-timer.C:
|
||||
default:
|
||||
}
|
||||
}
|
||||
var tick <-chan time.Time
|
||||
if delay, enabled := c.maintenanceDelay(); enabled {
|
||||
timer.Reset(delay)
|
||||
tick = timer.C
|
||||
}
|
||||
select {
|
||||
case <-c.done:
|
||||
return
|
||||
case <-c.activityWake:
|
||||
case req := <-c.reqCh:
|
||||
c.handle(req)
|
||||
case <-tick:
|
||||
c.maintainIdleCard()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -198,6 +226,21 @@ func (c *Client) handle(req cmdReq) {
|
||||
default:
|
||||
}
|
||||
|
||||
if req.passive {
|
||||
if !c.admitPassive(req.ctx, req.generation) {
|
||||
req.respCh <- cmdResp{}
|
||||
return
|
||||
}
|
||||
c.mu.RLock()
|
||||
st := append([]byte(nil), c.lastStatus...)
|
||||
fresh := len(st) == 4 && time.Since(c.lastStatusT) <= c.statusTTL
|
||||
c.mu.RUnlock()
|
||||
if fresh {
|
||||
c.setStock(st)
|
||||
req.respCh <- cmdResp{status: st}
|
||||
return
|
||||
}
|
||||
}
|
||||
switch req.typ {
|
||||
case cmdStatus:
|
||||
st, err := c.readWorkerStatus(req.ctx)
|
||||
@@ -300,20 +343,33 @@ func (c *Client) do(ctx context.Context, typ cmdType) ([]byte, error) {
|
||||
}
|
||||
|
||||
func (c *Client) doResponse(ctx context.Context, typ cmdType) cmdResp {
|
||||
rch := make(chan cmdResp, 1)
|
||||
req := cmdReq{typ: typ, ctx: ctx, respCh: rch}
|
||||
return c.sendRequest(cmdReq{typ: typ, ctx: ctx})
|
||||
}
|
||||
|
||||
func (c *Client) sendRequest(req cmdReq) cmdResp {
|
||||
if err := req.ctx.Err(); err != nil {
|
||||
return cmdResp{err: err}
|
||||
}
|
||||
req.respCh = make(chan cmdResp, 1)
|
||||
select {
|
||||
case <-c.done:
|
||||
return cmdResp{err: context.Canceled}
|
||||
default:
|
||||
}
|
||||
select {
|
||||
case c.reqCh <- req:
|
||||
case <-ctx.Done():
|
||||
return cmdResp{err: ctx.Err()}
|
||||
case <-c.done:
|
||||
return cmdResp{err: context.Canceled}
|
||||
case <-req.ctx.Done():
|
||||
return cmdResp{err: req.ctx.Err()}
|
||||
}
|
||||
|
||||
select {
|
||||
case r := <-rch:
|
||||
case r := <-req.respCh:
|
||||
return r
|
||||
case <-ctx.Done():
|
||||
return cmdResp{err: ctx.Err()}
|
||||
case <-c.done:
|
||||
return cmdResp{err: context.Canceled}
|
||||
case <-req.ctx.Done():
|
||||
return cmdResp{err: req.ctx.Err()}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user