bootstrap.go接口轮询

package bootstrap

import (
	"context"
	"path/filepath"
	"time"

	"icode.baidu.com/baidu/gdp/env"
	"icode.baidu.com/baidu/gdp/logit"
	"icode.baidu.com/baidu/gdp/mysql"
	"icode.baidu.com/baidu/gdp/net/ral"
	"icode.baidu.com/baidu/gdp/net/servicer"
	"icode.baidu.com/baidu/gdp/redis"
	"icode.baidu.com/baidu/gov/zw-gwy-app/library/resource"
	"icode.baidu.com/baidu/gov/zw-gwy-app/library/response"
	riskLevelServices "icode.baidu.com/baidu/gov/zw-gwy-app/models/services/epidemic_risk_level"
	policyServices "icode.baidu.com/baidu/gov/zw-gwy-app/models/services/policy"
	weatherServices "icode.baidu.com/baidu/gov/zw-gwy-app/models/services/weather"
)

// MustInit 组件初始化，若失败，会panic
func MustInit(ctx context.Context) {
	initLoggers(ctx)

	initRal(ctx)

	loadServicer(ctx)

	initMySQL(ctx)

	initRedis(ctx)

	initResponse()

	initTask(ctx)
}

// initResponse response相关初始化
func initResponse() {
	response.Init(env.ConfDir())
}

// initLoggers 初始化logger
func initLoggers(ctx context.Context) {
	{
		webLogger, err := logit.NewLogger(ctx, logit.OptConfigFile("logit/service.toml"))
		if err != nil {
			panic(err.Error())
		}
		resource.LoggerService = webLogger

		TryRegisterCloser(webLogger) // 注册closer,这样可以保证程序进程退出前，日志全部落盘
	}
}

// initRal 初始化服务配置 以及ral组件
func initRal(ctx context.Context) {
	ral.InitDefault(ctx)
}

// loadServicer 加载服务配置
func loadServicer(ctx context.Context) {
	pattern := filepath.Join(env.ConfDir(), "servicer", "*.toml")
	servicer.MustLoad(ctx, servicer.LoadOptFilesGlob(pattern, false))
}

// initMySQL 初始化mysql
func initMySQL(_ context.Context) {
	// client 初始化为单例，放到 resource 里去
	resource.MySQLClientUser = mustInitOneMySQL("mysql")
}

func mustInitOneMySQL(name interface{}) mysql.Client {
	opts := []mysql.ClientOption{
		mysql.OptObserver(mysql.NewMetricsObserverFunc(nil)),
	}
	client, err := mysql.NewClient(name, opts...)
	// 理论上，只有配置错误，才有可能返回err
	// 如配置不存在，配置内容错误
	if err != nil {
		panic(err.Error())
	}
	return client
}

// initRedis 初始化redis
func initRedis(_ context.Context) {
	// client 初始化为单例，放到 resource 里去
	resource.RedisUser = mustInitOneRedis("redis")
}

func mustInitOneRedis(name string) redis.Client {
	opts := []redis.ClientOption{
		redis.OptHooker(redis.NewMetricsHook(nil)),
		redis.OptHooker(redis.NewLogHook()),
	}

	client, err := redis.NewClient(name, opts...)
	// 理论上，只有配置错误，才有可能返回err
	// 如配置不存在，配置内容错误
	if err != nil {
		panic(err.Error())
	}
	return client
}

// initTask 初始化任务
func initTask(ctx context.Context) {
	//pollWeatherWarning(ctx)
	//pollYiqingPolicy(ctx)
	//pollingRiskLevelChange(ctx)
}

// pollYiqingPolicy 疫情防控政策措施轮询
func pollYiqingPolicy(ctx context.Context) {
	// 服务配置初始化为单例，每小时执行一次
	t := time.NewTicker(time.Duration(60) * time.Minute)
	ctxLog := logit.WithContext(ctx)

	go func(t *time.Ticker) {
		defer func() {
			if err := recover(); err != nil {
				resource.LoggerService.Warning(ctx, "pollWeatherWarning", logit.AutoField("panic", err))
			}
			t.Stop()
		}()

		for {
			select {
			case <-t.C:
				policyServices.PollPolicyData(ctxLog)
			}
		}
	}(t)
}

// pollingRiskLevelChange 轮询各地区风险等级变化情况并推送
func pollingRiskLevelChange(ctx context.Context) {
	// 服务配置初始化为单例，每小时执行一次
	t := time.NewTicker(time.Duration(60) * time.Minute)
	ctxLog := logit.WithContext(ctx)
	go func(t *time.Ticker) {
		defer func() {
			if err := recover(); err != nil {
				resource.LoggerService.Warning(ctx, "PollingRiskLevel", logit.AutoField("panic", err))
			}
			t.Stop()
		}()
		for {
			select {
			case <-t.C:
				riskLevelServices.PollingRiskLevel(ctxLog)
			}
		}
	}(t)
}

// pollWeatherWarning 天气预警轮询
func pollWeatherWarning(ctx context.Context) {
	// 服务配置初始化为单例，每小时执行一次
	t := time.NewTicker(time.Duration(60) * time.Minute)
	ctxLog := logit.WithContext(ctx)

	go func(t *time.Ticker) {
		defer func() {
			if err := recover(); err != nil {
				resource.LoggerService.Warning(ctx, "pollWeatherWarning", logit.AutoField("panic", err))
			}
			t.Stop()
		}()

		for {
			select {
			case <-t.C:
				weatherServices.PollAlarmData(ctxLog)
			}
		}
	}(t)
}