rtu_linux_services/timesyncd.service/main.go

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"net/http"
	"os"
	"rtu_linux_services/servicelib"
	"sync/atomic"
	"time"

	"github.com/kardianos/service"
	"hnyfkj.com.cn/rtu/linux/baseapp"
	"hnyfkj.com.cn/rtu/linux/netmgrd"
	"hnyfkj.com.cn/rtu/linux/utils/jsonrpc2"
)

var (
	Version   = "0.0.0.1"
	BuildTime = ""
)

const (
	network    = "tcp" // http -> tcp
	listenAddr = "127.0.0.1:7001"
)

type program struct {
	name         string
	core_server  *jsonrpc2.RPCServer
	http_server  *http.Server
	timeSyncOK   atomic.Bool
	syncSource   atomic.Value
	stopTimeSync chan struct{}
}

// Start should not block. Do the actual work async.
func (p *program) Start(s service.Service) error {
	baseapp.SetOptDirs(true, false, false, false)
	baseapp.InitPath()

	logCfgFile, err := servicelib.EnsureDefaultLogConfig()
	if err != nil {
		return err
	}

	baseapp.InitLogger(logCfgFile)
	baseapp.Logger.Infof("App Version: %s, Build Time: %s", Version, BuildTime)

	p.core_server, err = jsonrpc2.NewRPCServer(p.name, baseapp.Logger)
	if err != nil {
		return err
	}

	methods := make(jsonrpc2.MethodMap)

	//////////////////////////////////////////////////////////
	_getBuildVer := servicelib.MakeGetBuildVer(
		Version, BuildTime)
	methods["basic.getBuildVer"] = _getBuildVer // 获取软件版本
	_getLogLevel := servicelib.GetLogLevel
	methods["basic.getLogLevel"] = _getLogLevel // 获取日志级别
	_setLogLevel := servicelib.SetLogLevel
	methods["basic.setLogLevel"] = _setLogLevel // 设置日志级别
	_saveLogConf := servicelib.SaveLogConf
	methods["basic.saveLogConf"] = _saveLogConf // 保存日志设置
	//////////////////////////////////////////////////////////
	methods["core.getTimeSyncStatus"] = p.getTimeSyncStatus

	err = p.core_server.RegisterMethods(methods)
	if err != nil {
		return err
	}

	mux := http.NewServeMux()
	mux.Handle("/rpc", p.core_server)

	p.http_server = &http.Server{
		Addr:    listenAddr,
		Handler: mux,
	}

	p.stopTimeSync = make(chan struct{})
	p.syncSource.Store("")

	go p.run()

	return nil
}

// Do work here
func (p *program) run() {
	go p.maintainSystemTime()

	baseapp.Logger.Infof(
		"[%s] Http server starting on %s...",
		p.name,
		p.http_server.Addr,
	)

	err := p.http_server.ListenAndServe() // 同步阻塞

	if err != nil && !errors.Is(err, http.ErrServerClosed) {
		baseapp.Logger.Errorf("[%s] Start http server error: %v!!", p.name, err)
		return
	}
}

// Stop should not block. Return with a few seconds.
func (p *program) Stop(s service.Service) error {
	if p.stopTimeSync != nil {
		close(p.stopTimeSync)
	}

	if p.core_server != nil {
		p.core_server.Stop()
	}

	if p.http_server != nil {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()

		_ = p.http_server.Shutdown(ctx)
	}

	baseapp.ExitLogger()
	return nil
}

func (p *program) syncSysTime() error {
	_, _, tcpOK, httpOK, httpTime := netmgrd.CheckNetwork()
	if !(tcpOK || httpOK) {
		return errors.New("network not available")
	}

	if !httpTime.IsZero() && netmgrd.SetSystemTime(httpTime) == nil {
		p.syncSource.Store("http")
		return nil
	}

	err := netmgrd.SyncNTPTime()
	if err == nil {
		p.syncSource.Store("ntp")
		return nil
	} else {
		return err
	}
}

func (p *program) maintainSystemTime() {
	timer := time.NewTimer(0) // ->立即触发
	defer timer.Stop()

	for {
		select {
		case <-timer.C:
			if err := p.syncSysTime(); err != nil {
				p.timeSyncOK.Store(false)
				baseapp.Logger.Errorf("[%s] Failed to synchronize system time: %v!!", p.name, err)
				timer.Reset(time.Second)
				continue
			}
			p.timeSyncOK.Store(true)
			baseapp.Logger.Infof("[%s] ✅ System time synchronized successfully: %s", p.name, time.Now().Format("2006-01-02 15:04:05"))
			timer.Reset(time.Hour)

		case <-p.stopTimeSync:
			return
		}
	} // for end
}

func main() {
	svcFlag := flag.String("service", "", "Control the system service.")
	flag.Parse()

	svcConfig := &service.Config{
		Name:        "yfkj-timesyncd",
		DisplayName: "yfkj-timesyncd",
		Description: "System time synchronization",
		Option: map[string]any{
			"Restart": "on-failure",
		},
	}

	prg := &program{
		name: "TimeSync",
	}

	svc, err := service.New(prg, svcConfig)
	if err != nil {
		fmt.Printf("%s.service creation failed: %v\n",
			svcConfig.Name, err)
		os.Exit(1)
	}

	if len(*svcFlag) != 0 {
		err := service.Control(svc, *svcFlag)
		if err != nil {
			fmt.Printf("%v\n Valid actions: %q\n", err, service.ControlAction)
		}
		os.Exit(0)
	}

	if servicelib.IsAddrInUse(network, listenAddr) { // 查询端口占用，避免运行多份实例
		fmt.Printf(
			"%s.service start failed: listen addr %s already in use\n",
			svcConfig.Name, listenAddr,
		)
		os.Exit(1)
	}

	if err := svc.Run(); err != nil {
		fmt.Printf("%s.service run failed: %v\n",
			svcConfig.Name, err)
		os.Exit(1)
	}
}