mirror of https://github.com/XTLS/Xray-core
129 lines
3.5 KiB
Go
129 lines
3.5 KiB
Go
package proxy
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"math/big"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/xtls/xray-core/common/buf"
|
|
"github.com/xtls/xray-core/common/errors"
|
|
)
|
|
|
|
type Scheduler struct {
|
|
Buffer chan buf.MultiBuffer
|
|
Trigger chan int
|
|
Error chan error
|
|
TimeoutCounter int
|
|
TimeoutLock *sync.Mutex
|
|
closed chan int
|
|
bufferReadLock *sync.Mutex
|
|
writer buf.Writer
|
|
addons *Addons
|
|
trafficState *TrafficState
|
|
writeOnceUserUUID *[]byte
|
|
ctx context.Context
|
|
}
|
|
|
|
func TriggerScheduler(scheduler *Scheduler) buf.CopyOption {
|
|
return func(handler *buf.CopyHandler) {
|
|
handler.OnData = append(handler.OnData, func(buf.MultiBuffer) {
|
|
scheduler.Trigger <- 2 // send fake buffer if no pending
|
|
})
|
|
}
|
|
}
|
|
|
|
func NewScheduler(w buf.Writer, addon *Addons, state *TrafficState, userUUID *[]byte, context context.Context) *Scheduler {
|
|
var s = Scheduler{
|
|
Buffer: make(chan buf.MultiBuffer, 100),
|
|
Trigger: make(chan int),
|
|
Error: make(chan error, 100),
|
|
TimeoutCounter: 0,
|
|
TimeoutLock: new(sync.Mutex),
|
|
closed: make(chan int),
|
|
bufferReadLock: new(sync.Mutex),
|
|
writer: w,
|
|
addons: addon,
|
|
trafficState: state,
|
|
writeOnceUserUUID: userUUID,
|
|
ctx: context,
|
|
}
|
|
return &s
|
|
}
|
|
|
|
func(s *Scheduler) Start() {
|
|
go s.mainLoop()
|
|
if s.addons.Scheduler != nil && !s.addons.Scheduler.PingPong {
|
|
go s.exampleIndependentScheduler()
|
|
}
|
|
}
|
|
|
|
func(s *Scheduler) mainLoop() {
|
|
for trigger := range s.Trigger {
|
|
if len(s.closed) > 0 {
|
|
return
|
|
}
|
|
if trigger == -1 && s.addons.Scheduler != nil {
|
|
continue
|
|
}
|
|
if trigger == 2 && (s.addons.Scheduler == nil || !s.addons.Scheduler.PingPong) {
|
|
continue
|
|
}
|
|
go func() { // each trigger has independent delay, trigger does not block
|
|
var d = 0 * time.Millisecond
|
|
if s.addons.Delay != nil {
|
|
l, err := rand.Int(rand.Reader, big.NewInt(int64(s.addons.Delay.MaxMillis - s.addons.Delay.MinMillis)))
|
|
if err != nil {
|
|
errors.LogInfoInner(s.ctx, err, "failed to generate delay", trigger)
|
|
}
|
|
d = time.Duration(uint32(l.Int64()) + s.addons.Delay.MinMillis) * time.Millisecond
|
|
time.Sleep(d)
|
|
}
|
|
|
|
s.bufferReadLock.Lock() // guard against multiple trigger threads
|
|
var sending = len(s.Buffer)
|
|
if sending > 0 {
|
|
errors.LogDebug(s.ctx, "Scheduler Trigger for ", sending, " buffer(s) with ", d, " ", trigger)
|
|
for i := 0; i<sending; i++ {
|
|
err := s.writer.WriteMultiBuffer(<-s.Buffer)
|
|
if err != nil {
|
|
s.Error <- err
|
|
s.closed <- 1
|
|
return
|
|
}
|
|
}
|
|
} else if trigger > 0 && s.trafficState.IsPadding && ShouldStartSeed(s.addons, s.trafficState) && !ShouldStopSeed(s.addons, s.trafficState) {
|
|
errors.LogDebug(s.ctx, "Scheduler Trigger for fake buffer with ", d, " ", trigger)
|
|
s.trafficState.NumberOfPacketSent += 1
|
|
mb := make(buf.MultiBuffer, 1)
|
|
mb[0] = XtlsPadding(nil, CommandPaddingContinue, s.writeOnceUserUUID, true, s.addons, s.ctx)
|
|
s.trafficState.ByteSent += int64(mb.Len())
|
|
if s.trafficState.StartTime.IsZero() {
|
|
s.trafficState.StartTime = time.Now()
|
|
}
|
|
err := s.writer.WriteMultiBuffer(mb)
|
|
if err != nil {
|
|
s.Error <- err
|
|
s.closed <- 1
|
|
return
|
|
}
|
|
if buffered, ok := s.writer.(*buf.BufferedWriter); ok {
|
|
buffered.SetBuffered(false)
|
|
}
|
|
}
|
|
s.bufferReadLock.Unlock()
|
|
}()
|
|
}
|
|
}
|
|
|
|
func(s *Scheduler) exampleIndependentScheduler() {
|
|
for {
|
|
if len(s.closed) > 0 {
|
|
return
|
|
}
|
|
s.Trigger <- 1 // send fake buffer if no pending
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
}
|