refactor: 重构温度解析及telegram bot

Author: TBXark

app.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"context"
+	"github.com/go-telegram/bot"
+	"github.com/go-telegram/bot/models"
+	"log"
+	"time"
+)
+
+const (
+	highTempThreshold = 50.0
+	sleepDuration     = 10 * time.Minute
+)
+
+type Application struct {
+	conf *Config
+	bot  *bot.Bot
+}
+
+func NewApplication(conf *Config) (*Application, error) {
+	b, err := bot.New(conf.Token, bot.WithSkipGetMe())
+	if err != nil {
+		return nil, err
+	}
+	return &Application{
+		conf: conf,
+		bot:  b,
+	}, nil
+}
+
+func (a *Application) startMonitoring(ctx context.Context) {
+	for {
+		a.sendTemperatureToTelegram(ctx)
+		time.Sleep(sleepDuration)
+	}
+}
+
+func (a *Application) sendTemperatureToTelegram(ctx context.Context) {
+	temp, err := LoadSensorsTemperature()
+	if err != nil {
+		log.Printf("error getting system temp: %v", err)
+		return
+	}
+	_, err = a.bot.SendMessage(ctx, &bot.SendMessageParams{
+		ChatID:              a.conf.TargetId,
+		Text:                temp.RenderMessage(),
+		DisableNotification: temp.IsHigherThanThreshold(highTempThreshold),
+	})
+	if err != nil {
+		log.Printf("error sending message: %v", err)
+	}
+}
+
+func (a *Application) startPolling(ctx context.Context) {
+	a.bot.RegisterHandler(bot.HandlerTypeMessageText, "/temp", bot.MatchTypePrefix, func(ctx context.Context, bot *bot.Bot, update *models.Update) {
+		a.sendTemperatureToTelegram(ctx)
+	})
+	a.bot.Start(ctx)
+}

config.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+)
+
+type Config struct {
+	Token    string `json:"token"`
+	TargetId int64  `json:"target_id"`
+}
+
+func loadConfig(path string) (*Config, error) {
+	if strings.HasPrefix(path, "http") {
+		resp, err := http.Get(path)
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+		config := &Config{}
+		err = json.NewDecoder(resp.Body).Decode(config)
+		if err != nil {
+			return nil, err
+		}
+		return config, nil
+	} else {
+		file, err := os.ReadFile(path)
+		if err != nil {
+			log.Fatal(err)
+		}
+		config := &Config{}
+		err = json.Unmarshal(file, config)
+		if err != nil {
+			return nil, err
+		}
+		return config, nil
+	}
+}

go.mod

@@ -1 +1,11 @@
 module pve-status
+
+go 1.23.2
+
+require github.com/go-telegram/bot v1.10.1
+
+require (
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+)

go.sum

@@ -0,0 +1,11 @@
+github.com/go-telegram/bot v1.10.0 h1:/Y9ZupcZhYQiAOFE1ETCF8P4836XE42nDkLcWHYTg3g=
+github.com/go-telegram/bot v1.10.0/go.mod h1:i2TRs7fXWIeaceF3z7KzsMt/he0TwkVC680mvdTFYeM=
+github.com/go-telegram/bot v1.10.1 h1:zwbEjz6ZlqBsyT5EqNqZDYX1ogHIiln1lwYpcK3E8XA=
+github.com/go-telegram/bot v1.10.1/go.mod h1:i2TRs7fXWIeaceF3z7KzsMt/he0TwkVC680mvdTFYeM=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=

main.go

@@ -1,240 +1,16 @@
 package main
 
 import (
-	"bytes"
-	"encoding/json"
+	"context"
 	"flag"
 	"fmt"
 	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
 )
 
 var BuildVersion = "dev"
 
-const (
-	highTempThreshold = 50.0
-	sleepDuration     = 10 * time.Minute
-)
-
-func parseJsonNumber(n json.Number) (float64, error) {
-	if n == "" {
-		return 0, nil
-	}
-	return strconv.ParseFloat(string(n), 64)
-}
-
-func renderMessage() (string, float64, error) {
-	output, err := exec.Command("sensors", "-j").Output()
-	if err != nil {
-		return "", 0, err
-	}
-
-	var sensorData map[string]interface{}
-	if e := json.Unmarshal(output, &sensorData); e != nil {
-		return "", 0, e
-	}
-
-	cpuData, ok := sensorData["coretemp-isa-0000"].(map[string]interface{})
-	if !ok {
-		return "", 0, fmt.Errorf("failed to find CPU data")
-	}
-
-	packageData, ok := cpuData["Package id 0"].(map[string]interface{})
-	if !ok {
-		return "", 0, fmt.Errorf("failed to find Package id 0 data")
-	}
-
-	mainTemp, err := parseJsonNumber(json.Number(fmt.Sprintf("%v", packageData["temp1_input"])))
-	if err != nil {
-		return "", 0, err
-	}
-
-	warning := ""
-	if mainTemp > highTempThreshold {
-		warning = "⚠️ High Temperature Warning"
-	}
-
-	var coreTemps []string
-	coreTemps = append(coreTemps, fmt.Sprintf("%.1f", mainTemp))
-
-	for key, value := range cpuData {
-		if strings.HasPrefix(key, "Core") {
-			coreData, exist := value.(map[string]interface{})
-			if !exist {
-				continue
-			}
-			for k, v := range coreData {
-				if strings.HasSuffix(k, "_input") {
-					coreTemp, e := parseJsonNumber(json.Number(fmt.Sprintf("%v", v)))
-					if e == nil {
-						coreTemps = append(coreTemps, fmt.Sprintf("%.1f", coreTemp))
-					}
-					break
-				}
-			}
-		}
-	}
-
-	text := fmt.Sprintf("%s\nCPU: %s°C\n", warning, strings.Join(coreTemps, "°C | "))
-
-	if acpiData, exist := sensorData["acpitz-acpi-0"].(map[string]interface{}); exist {
-		if temp1, tExist := acpiData["temp1"].(map[string]interface{}); tExist {
-			if acpiTemp, aExist := temp1["temp1_input"]; aExist {
-				acpiTempFloat, _ := parseJsonNumber(json.Number(fmt.Sprintf("%v", acpiTemp)))
-				text += fmt.Sprintf("\nACPI: %.1f°C", acpiTempFloat)
-			}
-		}
-	}
-
-	text += "\n"
-
-	if nvmeData, exist := sensorData["nvme-pci-0400"].(map[string]interface{}); exist {
-		if composite, cExist := nvmeData["Composite"].(map[string]interface{}); cExist {
-			if nvmeTemp, nExist := composite["temp1_input"]; nExist {
-				nvmeTempFloat, _ := parseJsonNumber(json.Number(fmt.Sprintf("%v", nvmeTemp)))
-				text += fmt.Sprintf("\nNVME: %.1f°C", nvmeTempFloat)
-			}
-		}
-	}
-
-	return text, mainTemp, nil
-}
-
-func sendPVEStatusToTelegram(text string, temp float64, conf *Config) error {
-	data := map[string]interface{}{
-		"chat_id":              conf.TargetId,
-		"text":                 text,
-		"disable_notification": temp <= 50,
-	}
-	jsonData, err := json.Marshal(data)
-	if err != nil {
-		return err
-	}
-
-	req, err := http.NewRequest("POST", fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", conf.Token), bytes.NewBuffer(jsonData))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("request failed with status code: %s", resp.Status)
-	}
-
-	defer log.Printf("%.1f°C", temp)
-
-	if !conf.PinLatest {
-		return nil
-	}
-
-	var respData struct {
-		Result struct {
-			MessageId int64 `json:"message_id"`
-		}
-	}
-	err = json.NewDecoder(resp.Body).Decode(&respData)
-	if err != nil {
-		return err
-	}
-
-	err = pinMessageToTelegram(conf, respData.Result.MessageId)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func pinMessageToTelegram(conf *Config, messageId int64) error {
-	// unpin all messages
-	data := map[string]interface{}{
-		"chat_id": conf.TargetId,
-	}
-	jsonData, err := json.Marshal(data)
-	if err != nil {
-		return err
-	}
-	req, err := http.NewRequest("POST", fmt.Sprintf("https://api.telegram.org/bot%s/unpinAllChatMessages", conf.Token), bytes.NewBuffer(jsonData))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	// pin the message
-	data = map[string]interface{}{
-		"chat_id":              conf.TargetId,
-		"message_id":           messageId,
-		"disable_notification": true,
-	}
-	jsonData, err = json.Marshal(data)
-	if err != nil {
-		return err
-	}
-	req, err = http.NewRequest("POST", fmt.Sprintf("https://api.telegram.org/bot%s/pinChatMessage", conf.Token), bytes.NewBuffer(jsonData))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	return nil
-}
-
-func loadConfig(path string) (*Config, error) {
-	if strings.HasPrefix(path, "http") {
-		resp, err := http.Get(path)
-		if err != nil {
-			return nil, err
-		}
-		defer resp.Body.Close()
-		config := &Config{}
-		err = json.NewDecoder(resp.Body).Decode(config)
-		if err != nil {
-			return nil, err
-		}
-		return config, nil
-	} else {
-		file, err := os.ReadFile(path)
-		if err != nil {
-			log.Fatal(err)
-		}
-		config := &Config{}
-		err = json.Unmarshal(file, config)
-		if err != nil {
-			return nil, err
-		}
-		return config, nil
-	}
-}
-
-type Config struct {
-	Token     string `json:"token"`
-	TargetId  int64  `json:"target_id"`
-	PinLatest bool   `json:"pin_latest"`
-}
-
 func main() {
-	conf := flag.String("config", "config.json", "config file path")
+	config := flag.String("config", "config.json", "config file path")
 	help := flag.Bool("help", false, "show help")
 	flag.Parse()
 
@@ -243,20 +19,14 @@ func main() {
 		flag.Usage()
 		return
 	}
-
-	config, err := loadConfig(*conf)
+	conf, err := loadConfig(*config)
 	if err != nil {
 		log.Fatal(err)
 	}
-	for {
-		text, temp, e := renderMessage()
-		if e != nil {
-			log.Printf("Error rendering message: %v", e)
-			continue
-		}
-		if se := sendPVEStatusToTelegram(text, temp, config); se != nil {
-			log.Printf("Error sending message to Telegram: %v", se)
-		}
-		time.Sleep(sleepDuration)
+	app, err := NewApplication(conf)
+	if err != nil {
+		log.Fatal(err)
 	}
+	go app.startPolling(context.Background())
+	app.startMonitoring(context.Background())
 }