modelRT/deploy/redis-test-data/real-time-compute/compute_data_injection.go

// Package main implement redis test data injection
package main

import (
	"context"
	"fmt"
	"log"
	"math/rand"
	"strconv"
	"time"

	"modelRT/orm"

	util "modelRT/deploy/redis-test-data/util"

	"github.com/redis/go-redis/v9"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

const (
	redisAddr = "localhost:6379"
)

var globalRedisClient *redis.Client

var (
	highEnd, highStart, lowStart, lowEnd int
	totalLength                          int
	highSegmentLength                    int
	lowSegmentLength                     int
)

func selectRandomInt() int {
	options := []int{0, 2}
	randomIndex := rand.Intn(len(options))
	return options[randomIndex]
}

// generateMixedData define func to generate a set of floating-point data that meets specific conditions
func generateMixedData(highMin, lowMin, highBase, lowBase, baseValue, normalBase float64) []float64 {
	totalLength = 500
	highSegmentLength = 20
	lowSegmentLength = 20

	seed := time.Now().UnixNano()
	source := rand.NewSource(seed)
	r := rand.New(source)

	data := make([]float64, totalLength)
	highStart = rand.Intn(totalLength - highSegmentLength - lowSegmentLength - 1)
	highEnd = highStart + highSegmentLength
	lowStart = rand.Intn(totalLength-lowSegmentLength-highEnd) + highEnd
	lowEnd = lowStart + lowSegmentLength

	for i := 0; i < totalLength; i++ {
		if i >= highStart && i < highStart+highSegmentLength {
			// 数据值均大于 55.0，在 [55.5, 60.0] 范围内随机
			// rand.Float64() 生成 [0.0, 1.0) 范围的浮点数
			data[i] = highMin + r.Float64()*(highBase)
		} else if i >= lowStart && i < lowStart+lowSegmentLength {
			// 数据值均小于 45.0，在 [40.0, 44.5] 范围内随机
			data[i] = lowMin + r.Float64()*(lowBase)
		} else {
			// 数据在 [45.0, 55.0] 范围内随机 (baseValue ± 5)
			// 50 + rand.Float64() * 10 - 5
			change := normalBase - r.Float64()*normalBase*2
			data[i] = baseValue + change
		}
	}
	return data
}

func generateNormalData(baseValue, normalBase float64) []float64 {
	totalLength = 500
	seed := time.Now().UnixNano()
	source := rand.NewSource(seed)
	r := rand.New(source)

	data := make([]float64, totalLength)
	for i := 0; i < totalLength; i++ {
		change := normalBase - r.Float64()*normalBase*2
		data[i] = baseValue + change
	}
	return data
}

func main() {
	rootCtx := context.Background()

	pgURI := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s", "192.168.1.101", 5432, "postgres", "coslight", "demo")

	postgresDBClient, err := gorm.Open(postgres.Open(pgURI))
	if err != nil {
		panic(err)
	}
	defer func() {
		sqlDB, err := postgresDBClient.DB()
		if err != nil {
			panic(err)
		}
		sqlDB.Close()
	}()

	cancelCtx, cancel := context.WithTimeout(rootCtx, 5*time.Second)
	defer cancel()
	var measurements []orm.Measurement
	result := postgresDBClient.WithContext(cancelCtx).Find(&measurements)
	if result.Error != nil {
		panic(result.Error)
	}
	log.Println("总共读取到测量点数量:", len(measurements))
	measInfos := util.ProcessMeasurements(measurements)

	globalRedisClient = util.InitRedisClient(redisAddr)
	rCancelCtx, cancel := context.WithCancel(rootCtx)
	defer cancel()

	for key, measInfo := range measInfos {
		randomType := selectRandomType()
		var datas []float64
		if randomType {
			// 生成正常数据
			log.Printf("key:%s generate normal data type is %v\n", key, randomType)
			baseValue := measInfo.BaseValue
			changes := measInfo.Changes
			normalBase := changes[0]
			noramlMin := baseValue - normalBase
			normalMax := baseValue + normalBase
			datas = generateNormalData(baseValue, normalBase)
			allTrue := true

			for i := 0; i < totalLength-1; i++ {
				value := datas[i]
				// log.Printf("index:%d, value:%.2f\n", i, value)
				if value < noramlMin && value > normalMax {
					allTrue = false
				}
			}
			log.Printf("// 验证结果: 所有值是否 >= %.2f或 <= %.2f %t\n", noramlMin, normalMax, allTrue)
		} else {
			// 生成异常数据
			log.Printf("key:%s generate abnormal data type is %v\n", key, randomType)
			var highMin, highBase float64
			var lowMin, lowBase float64
			var normalBase float64

			// TODO 生成一次测试数据
			changes := measInfo.Changes
			baseValue := measInfo.BaseValue
			if len(changes) == 2 {
				highMin = baseValue + changes[0]
				lowMin = baseValue + changes[1]
				highBase = changes[0]
				lowBase = changes[1]
				normalBase = changes[0]
			} else {
				randomIndex := selectRandomInt()
				highMin = baseValue + changes[randomIndex]
				lowMin = baseValue + changes[randomIndex+1]
				highBase = changes[randomIndex]
				lowBase = changes[randomIndex+1]
				normalBase = changes[0]
			}

			datas = generateMixedData(highMin, lowMin, highBase, lowBase, baseValue, normalBase)
			// log.Printf("key:%s\n datas:%v\n", key, datas)

			allHigh := true
			for i := highStart; i < highEnd; i++ {
				if datas[i] <= highMin {
					allHigh = false
					break
				}
			}
			log.Printf("// 验证结果 (高值段在 %d-%d): 所有值是否 >  %.2f? %t\n", highStart, highEnd-1, highMin, allHigh)

			allLow := true
			for i := lowStart; i < lowEnd; i++ {
				if datas[i] >= lowMin {
					allLow = false
					break
				}
			}
			log.Printf("// 验证结果 (低值段在 %d-%d): 所有值是否 < %.2f? %t\n", lowStart, lowEnd-1, lowMin, allLow)

			allTrue := true
			for i := 0; i < totalLength-1; i++ {
				value := datas[i]
				if i < highStart || (i >= highEnd && i < lowStart) || i >= lowEnd {
					// log.Printf("index:%d, value:%.2f\n", i, value)
					if value >= highMin && value <= lowMin {
						allTrue = false
					}
				}
			}
			log.Printf("// 验证结果 (正常段在 %d-%d): 所有值是否 <= %.2f或>= %.2f %t\n", 0, totalLength-1, highMin, lowMin, allTrue)
		}
		log.Printf("启动数据写入程序, Redis Key: %s, 基准值: %.4f, 变化范围: %+v\n", key, measInfo.BaseValue, measInfo.Changes)
		pipe := globalRedisClient.Pipeline()
		redisZs := make([]redis.Z, 0, totalLength)
		currentTime := time.Now().UnixNano()
		for i := range totalLength {
			sequentialTime := currentTime + int64(i)
			z := redis.Z{
				Score:  datas[i],
				Member: strconv.FormatInt(sequentialTime, 10),
			}
			redisZs = append(redisZs, z)
		}
		log.Printf("启动数据写入程序, Redis Key: %s, 写入数据量: %d\n", key, len(redisZs))
		pipe.ZAdd(rCancelCtx, key, redisZs...)
		_, err = pipe.Exec(rCancelCtx)
		if err != nil {
			log.Printf("redis pipeline execution failed: %v\n", err)
		}
	}
}

func selectRandomType() bool {
	options := []int{0, 2}
	randomValue := rand.Intn(len(options))
	return randomValue != 0
}