mihomo/ntp/service.go

110 lines
2.3 KiB
Go
Raw Normal View History

2023-09-01 03:11:35 +08:00
package ntp
import (
"context"
"github.com/Dreamacro/clash/log"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/sing/common/ntp"
2023-09-01 03:11:35 +08:00
"sync"
"time"
)
var offset time.Duration
var service *Service
type Service struct {
server M.Socksaddr
ticker *time.Ticker
ctx context.Context
cancel context.CancelFunc
mu sync.Mutex
syncSystemTime bool
running bool
2023-09-01 03:11:35 +08:00
}
func ReCreateNTPService(server string, interval time.Duration, syncSystemTime bool) {
2023-09-01 03:11:35 +08:00
if service != nil {
service.Stop()
}
ctx, cancel := context.WithCancel(context.Background())
service = &Service{
ctx: ctx,
cancel: cancel,
server: M.ParseSocksaddr(server),
ticker: time.NewTicker(interval * time.Minute),
syncSystemTime: syncSystemTime,
}
2023-09-01 03:11:35 +08:00
service.Start()
}
func (srv *Service) Start() {
srv.mu.Lock()
defer srv.mu.Unlock()
log.Infoln("NTP service start, sync system time is %t", srv.syncSystemTime)
2023-09-01 03:11:35 +08:00
service.running = true
srv.update()
go srv.loopUpdate()
2023-09-01 03:11:35 +08:00
}
func (srv *Service) Stop() {
srv.mu.Lock()
defer srv.mu.Unlock()
2023-09-02 12:37:43 +08:00
if service.running {
srv.ticker.Stop()
srv.cancel()
service.running = false
}
}
func (srv *Service) Running() bool {
if srv == nil {
return false
}
srv.mu.Lock()
defer srv.mu.Unlock()
return srv.running
2023-09-01 03:11:35 +08:00
}
func (srv *Service) update() {
response, err := ntp.Exchange(context.Background(), N.SystemDialer, srv.server)
if err != nil || response == nil {
log.Errorln("initialize time: %s", err)
2023-09-01 03:11:35 +08:00
}
offset = response.ClockOffset
2023-09-01 03:11:35 +08:00
if offset > time.Duration(0) {
log.Infoln("System clock is ahead of NTP time by %s", offset)
2023-09-01 03:11:35 +08:00
} else if offset < time.Duration(0) {
log.Infoln("System clock is behind NTP time by %s", -offset)
}
if srv.syncSystemTime {
timeNow := response.Time
err = setSystemTime(timeNow)
if err == nil {
log.Infoln("sync system time success: %s", timeNow.Local().Format(ntp.TimeLayout))
} else {
log.Errorln("write time to system: %s", err)
srv.syncSystemTime = false
}
}
}
func (srv *Service) loopUpdate() {
for {
select {
case <-srv.ctx.Done():
return
case <-srv.ticker.C:
}
srv.update()
2023-09-01 03:11:35 +08:00
}
}
func Now() time.Time {
now := time.Now()
2023-09-02 12:37:43 +08:00
if service.Running() && offset.Abs() > 0 {
2023-09-01 03:11:35 +08:00
now = now.Add(offset)
}
return now
}