Switched logs back to uncompressed. Replay now supported with command line arguments. specify -h for help with arguments

main/gen_gdl90.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"bufio"
-	"compress/gzip"
+	"flag"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -76,11 +76,11 @@ var Crc16Table [256]uint16
 var mySituation SituationData
 
 // File handles for replay logging.
-var uatReplayWriter *gzip.Writer
+var uatReplayWriter *os.File
-var esReplayWriter *gzip.Writer
+var esReplayWriter *os.File
-var gpsReplayWriter *gzip.Writer
+var gpsReplayWriter *os.File
-var ahrsReplayWriter *gzip.Writer
+var ahrsReplayWriter *os.File
-var dump1090ReplayWriter *gzip.Writer
+var dump1090ReplayWriter *os.File
 
 type msg struct {
 	MessageClass    uint
@@ -143,11 +143,11 @@ func constructFilenames() {
 	}
 	fo.Sync()
 	fo.Close()
-	uatReplayLog = fmt.Sprintf("%s/%04d-uat.log.gz",logDirectory,fileIndexNumber)
+	uatReplayLog = fmt.Sprintf("%s/%04d-uat.log",logDirectory,fileIndexNumber)
-	esReplayLog = fmt.Sprintf("%s/%04d-es.log.gz",logDirectory,fileIndexNumber)
+	esReplayLog = fmt.Sprintf("%s/%04d-es.log",logDirectory,fileIndexNumber)
-	gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log.gz",logDirectory,fileIndexNumber)
+	gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log",logDirectory,fileIndexNumber)
-	ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log.gz",logDirectory,fileIndexNumber)
+	ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log",logDirectory,fileIndexNumber)
-	dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log.gz",logDirectory,fileIndexNumber)
+	dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log",logDirectory,fileIndexNumber)
 }
 
 // Construct the CRC table. Adapted from FAA ref above.
@@ -551,22 +551,22 @@ func replayLog(msg string, msgclass int) {
 	if len(msg) == 0 { // Blank message.
 		return
 	}
-	var wt *gzip.Writer
+	var fp *os.File
 	switch msgclass {
 	case MSGCLASS_UAT:
-		wt = uatReplayWriter
+		fp = uatReplayWriter
 	case MSGCLASS_ES:
-		wt = esReplayWriter
+		fp = esReplayWriter
 	case MSGCLASS_GPS:
-		wt = gpsReplayWriter
+		fp = gpsReplayWriter
 	case MSGCLASS_AHRS:
-		wt = ahrsReplayWriter
+		fp = ahrsReplayWriter
 	case MSGCLASS_DUMP1090:
-		wt = dump1090ReplayWriter
+		fp = dump1090ReplayWriter
 	}
-	if wt != nil {
+	if fp != nil {
 		s := makeReplayLogEntry(msg)
-		wt.Write([]byte(s))
+		fp.Write([]byte(s))
 	}
 }
 
@@ -883,19 +883,17 @@ func replayMark(active bool) {
 
 }
 
-func openReplay(fn string) (*gzip.Writer, error) {
+func openReplay(fn string) (*os.File, error) {
 	fp, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 
 	if err != nil {
 		log.Printf("Failed to open log file '%s': %s\n", fn, err.Error())
 		return nil, err
-	}
+	} else {
-
-	gzw := gzip.NewWriter(fp) //FIXME: Close() on the gzip.Writer will not close the underlying file.
 		timeFmt := "Mon Jan 2 15:04:05 -0700 MST 2006"
-	s := fmt.Sprintf("START,%s,%s\n", timeStarted.Format(timeFmt), time.Now().Format(timeFmt)) // Start time marker.
+		fmt.Fprintf(fp, "START,%s,%s\n", timeStarted.Format(timeFmt), time.Now().Format(timeFmt)) // Start time marker.	
-	gzw.Write([]byte(s))
+	}
-	return gzw, err
+	return fp, err
 }
 
 func printStats() {
@@ -913,7 +911,73 @@ func printStats() {
 	}
 }
 
+var uatReplayDone bool
+
+func uatReplay(f *os.File, replaySpeed uint64) {
+	rdr := bufio.NewReader(f)
+	curTick := int64(0)
+	for {
+		buf, err := rdr.ReadString('\n')
+		if err != nil {
+			break
+		}
+		linesplit := strings.Split(buf, ",")
+		if len(linesplit) < 2 { // Blank line or invalid.
+			continue
+		}
+		if linesplit[0] == "START" { // Reset ticker, new start.
+			curTick = 0
+		} else { // If it's not "START", then it's a tick count.
+			i, err := strconv.ParseInt(linesplit[0], 10, 64)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "invalid tick: '%s'\n", linesplit[0])
+				continue
+			}
+			thisWait := (i - curTick) / int64(replaySpeed)
+
+			if thisWait >= 120000000000 { // More than 2 minutes wait, skip ahead.
+				fmt.Fprintf(os.Stderr, "UAT skipahead - %d seconds.\n", thisWait/1000000000)
+			} else {
+				time.Sleep(time.Duration(thisWait) * time.Nanosecond) // Just in case the units change.
+			}
+
+			p := strings.Trim(linesplit[1], " ;\r\n")
+			fmt.Printf("%s;\n", p)
+			buf := fmt.Sprintf("%s;\n", p)
+			o, msgtype := parseInput(buf)
+			if o != nil && msgtype != 0 {
+				relayMessage(msgtype, o)
+			}
+			curTick = i
+		}
+	}
+	uatReplayDone = true
+}
+
+
+
+func openReplayFile(fn string) *os.File {
+	f, err := os.Open(fn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error opening '%s': %s\n", fn, err.Error())
+		os.Exit(1)
+		return nil
+	}
+	return f
+}
+
+
 func main() {
+	
+//	replayESFilename := flag.String("eslog", "none", "ES Log filename")
+	replayUATFilename := flag.String("uatlog", "none", "UAT Log filename")
+	debugFlag := flag.Bool("debug", false, "Debug enabled")
+	uatFlag   := flag.Bool("uatdisable", false, "Disable UAT reader")
+	replayFlag := flag.Bool("replay", false, "Replay file flag")
+	replaySpeed := flag.Int("speed", 1, "Replay speed multiplier")
+	
+	flag.Parse()
+	
 	timeStarted = time.Now()
 	runtime.GOMAXPROCS(runtime.NumCPU()) // redundant with Go v1.5+ compiler
 
@@ -934,7 +998,21 @@ func main() {
 	MsgLog = make([]msg, 0)
 
 	crcInit() // Initialize CRC16 table.
+	if *uatFlag == true {
+	   log.Printf("UAT flag true!\n")
+	}
+	if *debugFlag == true {
+	   log.Printf("Debug flag true!\n")
+	}
+	if *replayFlag == true {
+//		if (*replayESFilename == "none") || (*replayUATFilename == "none") {
+//			log.Fatal("Must specify both UAT and ES log files\n")
+//		}
+		log.Printf("Replay file %s\n", *replayUATFilename)
+	}
+	if *uatFlag != true {
 		sdrInit()
+	}
 	initTraffic()
 
 	globalStatus.Version = stratuxVersion
@@ -1000,6 +1078,27 @@ func main() {
 
 	reader := bufio.NewReader(os.Stdin)
 
+	if *replayFlag == true {
+		f := openReplayFile(*replayUATFilename)
+//		if len(os.Args) >= 4 {
+//			i, err := strconv.ParseUint(os.Args[3], 10, 64)
+//			if err == nil {
+//				replaySpeed = i
+//			}
+//		}
+		playSpeed := uint64(*replaySpeed)
+		fmt.Fprintf(os.Stderr, "Replay speed: %dx\n", playSpeed)
+		go uatReplay(f, playSpeed)
+//		go esReplay(f2, playSpeed)
+		for {
+			time.Sleep(1 * time.Second)
+			if uatReplayDone {
+			//&& esDone {
+				return
+			}
+		}
+	
+	} else {
 		for {
 			buf, err := reader.ReadString('\n')
 			if err != nil {
@@ -1011,5 +1110,5 @@ func main() {
 				relayMessage(msgtype, o)
 			}
 		}
-
+	}
 }