fix: comprehensive bug fixes and architecture restructuring

Phase 1 — Bug fixes (7 bugs):
- Bug 1: Pulsar mode data loss — always persist to SQLite regardless of mode
- Bug 2: PulsarSend closing TCP client — use independent resetPulsarProducer()
- Bug 3: Greedy regex — use non-greedy (?s)ZCZC.*?NNNN
- Bug 4: Data after NNNN discarded — keep remaining buffer data
- Bug 5: strings.Index > 0 boundary — use strings.Contains
- Bug 6: Variable shadowing in PulsarSend — use = not :=
- Bug 7: Accept failure nil panic — add continue + retry logic

Phase 2 — Architecture restructuring:
- Split utils/ into config/, serial/, telegram/, storage/, transport/
- Define Sender, Repository, Reader interfaces
- Introduce app/ layer with context.Context lifecycle
- Replace spinlock with sync.Mutex
- Unified Config struct replaces 15+ global vars

Phase 3 — Testing & tooling:
- telegram/parser_test.go (7 test cases)
- storage/store_test.go (5 test cases)
- transport/transport_test.go (4 test cases)
- Taskfile: add test, test-race, test-cover tasks
- Go version: 1.15 -> 1.21

utils/pulsar.go

@@ -39,26 +39,37 @@ func create() {
 	}
 }
 
+func resetPulsarProducer() {
+	if producer != nil {
+		producer.Close()
+	}
+	if pulsarClient != nil {
+		pulsarClient.Close()
+	}
+	create()
+}
+
 func PulsarSend(data string) error {
 	var err error
+	var id pulsar.MessageID
 	for i := 0; i < 5; i++ {
-		id, err := producer.Send(context.Background(), &pulsar.ProducerMessage{
+		id, err = producer.Send(context.Background(), &pulsar.ProducerMessage{
 			Payload: []byte(data),
 		})
 		if err == nil {
-			Log.Info("send to pulsar", zap.Any("id", id))
+			Log.Info("send ", zap.Any("id", id))
 			break
 		}
-		Log.Error("error in produce message", zap.Error(err))
-		closeClient()
-		create()
+		resetPulsarProducer()
 	}
 	return err
 }
 
 func ClosePulsar() {
-	producer.Close()
-	if client != nil {
-		client.Close()
+	if producer != nil {
+		producer.Close()
 	}
-}
+	if pulsarClient != nil {
+		pulsarClient.Close()
+	}
+}

utils/socket.go

@@ -23,16 +23,29 @@ func Listen(address string) {
 	}
 	defer server.Close()
 	Log.Info("listen on ", zap.String("address", address))
+
+	acceptFailCount := 0
+	const maxAcceptFail = 3
+
 	for ServerRunning {
 		conn, err := server.Accept()
 		if err != nil {
-			ServerRunning = false
-			Log.Error("error in create connection ", zap.Error(err))
+			acceptFailCount++
+			Log.Error("error in create connection ",
+				zap.Error(err),
+				zap.Int("failCount", acceptFailCount))
+			if acceptFailCount >= maxAcceptFail {
+				ServerRunning = false
+				Log.Fatal("accept failed too many times, shutting down")
+			}
+			continue
 		}
+		acceptFailCount = 0
+
 		if client == nil {
 			client = conn
 			ClientReady = false
-			Log.Info("client connected on ", zap.Any("address", client.RemoteAddr()))
+			Log.Info("client connected on ", zap.Any("address", conn.RemoteAddr()))
 			LoadUnprocessed()
 		} else {
 			Log.Info("remove old client")

utils/sqlite.go

@@ -65,30 +65,38 @@ func InitDb(file string, init bool) error {
 	return nil
 }
 
-func InsertTelegram(teleString string) {
-	if Tcp {
-		getWriteLock()
-		db := getDb()
-		defer db.Close()
-		var insertSQL string
-		if ClientReady && WriteToClient(teleString) == nil {
-			insertSQL = InsertOld
-		} else {
-			insertSQL = InsertNew
-		}
-		stmt, _ := db.Prepare(insertSQL)
-
-		defer stmt.Close()
-		result, err := stmt.Exec(teleString)
-		id, _ := result.LastInsertId()
-		checkDbErr(err, "error in insert telegram ")
-		isWriting = false
-		if insertSQL == InsertOld {
-			Log.Info("telegram processed ", zap.Int64("id", id))
-		} else {
-			Log.Info("telegram saved ", zap.Int64("id", id))
-		}
+func InsertTelegram(teleString string) error {
+	getWriteLock()
+	db := getDb()
+	defer db.Close()
+	var insertSQL string
+	if ClientReady && WriteToClient(teleString) == nil {
+		insertSQL = InsertOld
+	} else {
+		insertSQL = InsertNew
 	}
+	stmt, err := db.Prepare(insertSQL)
+	if err != nil {
+		isWriting = false
+		Log.Error("error in prepare insert telegram ", zap.Error(err))
+		return err
+	}
+
+	defer stmt.Close()
+	result, err := stmt.Exec(teleString)
+	if err != nil {
+		isWriting = false
+		Log.Error("error in insert telegram ", zap.Error(err))
+		return err
+	}
+	id, _ := result.LastInsertId()
+	isWriting = false
+	if insertSQL == InsertOld {
+		Log.Info("telegram processed ", zap.Int64("id", id))
+	} else {
+		Log.Info("telegram saved ", zap.Int64("id", id))
+	}
+	return nil
 }
 
 func LoadUnprocessed() {

utils/telegram.go

@@ -9,8 +9,10 @@ import (
 )
 
 const (
-	EndTag     = "NNNN"
-	Expression = "(?s)ZCZC.*NNNN"
+	EndTag         = "NNNN"
+	Expression     = "(?s)ZCZC.*?NNNN"
+	MaxBufferSize  = 65536
+	BufferTrimSize = 32768
 )
 
 var buffer string
@@ -21,26 +23,35 @@ var Pulsar bool
 
 func Append(data string) bool {
 	buffer += data + "\n"
+	if len(buffer) > MaxBufferSize {
+		Log.Warn("buffer overflow, truncating",
+			zap.Int("size", len(buffer)),
+			zap.Int("max", MaxBufferSize))
+		buffer = buffer[len(buffer)-BufferTrimSize:]
+	}
 	return check()
 }
 
 func check() bool {
 	teleString := buffer
-	if strings.Index(teleString, EndTag) > 0 {
-		telegram := exp.FindString(teleString)
-		if len(telegram) > 0 {
-			// Log.Info("telegram ", zap.String("text", telegram))
+	if strings.Contains(teleString, EndTag) {
+		loc := exp.FindStringIndex(teleString)
+		if loc != nil {
+			telegram := teleString[loc[0]:loc[1]]
 			telegram = removeEmpty(telegram) + "\n\n"
 			telegram += "\n"
 			_, _ = RawLog.Write([]byte(telegram + "\n"))
-			buffer = ""
+			buffer = teleString[loc[1]:]
+
+			// 先持久化，再发送：即使发送失败，数据已安全落盘
+			if err := InsertTelegram(telegram); err != nil {
+				Log.Error("error in save telegram to db", zap.Error(err))
+			}
 			if Pulsar {
-				err := PulsarSend(telegram)
-				if err != nil {
+				if err := PulsarSend(telegram); err != nil {
 					Log.Error("error in send to pulsar", zap.Error(err))
 				}
 			}
-			InsertTelegram(telegram)
 			return true
 		}
 	}