Cleanup.

main/gen_gdl90.go

@@ -2,10 +2,10 @@ package main
 
 import (
 	"bufio"
-	"flag"
 	"compress/gzip"
 	"encoding/hex"
 	"encoding/json"
+	"flag"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -76,17 +76,17 @@ var Crc16Table [256]uint16
 // Current AHRS, pressure altitude, etc.
 var mySituation SituationData
 
+type WriteCloser interface {
+	io.Writer
+	io.Closer
+}
+
 // File handles for replay logging.
-var uatReplayWriter *os.File
+var uatReplayWriter WriteCloser
-var uatReplayWriterGzip *gzip.Writer
+var esReplayWriter WriteCloser
-var esReplayWriter *os.File
+var gpsReplayWriter WriteCloser
-var esReplayWriterGzip *gzip.Writer
+var ahrsReplayWriter WriteCloser
-var gpsReplayWriter *os.File
+var dump1090ReplayWriter WriteCloser
-var gpsReplayWriterGzip *gzip.Writer
-var ahrsReplayWriter *os.File
-var ahrsReplayWriterGzip *gzip.Writer
-var dump1090ReplayWriter *os.File
-var dump1090ReplayWriterGzip *gzip.Writer
 
 var developerMode bool
 
@@ -115,21 +115,20 @@ type ADSBTower struct {
 	Messages_total              uint64
 }
 
-
 var ADSBTowers map[string]ADSBTower // Running list of all towers seen. (lat,lng) -> ADSBTower
 
 func constructFilenames() {
 	var fileIndexNumber uint
 
 	// First, create the log file directory if it does not exist
-	os.Mkdir(logDirectory,0644)
+	os.Mkdir(logDirectory, 0644)
 
 	f, err := os.Open(indexFilename)
 	if err != nil {
 		log.Printf("Unable to open index file %s using index of 0\n", indexFilename)
-		fileIndexNumber=0
+		fileIndexNumber = 0
 	} else {
-	  _, err := fmt.Fscanf(f,"%d\n",&fileIndexNumber)
+		_, err := fmt.Fscanf(f, "%d\n", &fileIndexNumber)
 		if err != nil {
 			log.Printf("Unable to read index file %s using index of 0\n", indexFilename)
 		}
@@ -140,24 +139,24 @@ func constructFilenames() {
 	if err != nil {
 		log.Printf("Error creating index file %s\n", indexFilename)
 	}
-	_, err2 := fmt.Fprintf(fo,"%d\n",fileIndexNumber)
+	_, err2 := fmt.Fprintf(fo, "%d\n", fileIndexNumber)
 	if err2 != nil {
 		log.Printf("Error writing to index file %s\n", indexFilename)
 	}
 	fo.Sync()
 	fo.Close()
 	if developerMode == true {
-		uatReplayLog = fmt.Sprintf("%s/%04d-uat.log",logDirectory,fileIndexNumber)
+		uatReplayLog = fmt.Sprintf("%s/%04d-uat.log", logDirectory, fileIndexNumber)
-		esReplayLog = fmt.Sprintf("%s/%04d-es.log",logDirectory,fileIndexNumber)
+		esReplayLog = fmt.Sprintf("%s/%04d-es.log", logDirectory, fileIndexNumber)
-		gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log",logDirectory,fileIndexNumber)
+		gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log", logDirectory, fileIndexNumber)
-		ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log",logDirectory,fileIndexNumber)
+		ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log", logDirectory, fileIndexNumber)
-		dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log",logDirectory,fileIndexNumber)
+		dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log", logDirectory, fileIndexNumber)
 	} else {
-		uatReplayLog = fmt.Sprintf("%s/%04d-uat.log.gz",logDirectory,fileIndexNumber)
+		uatReplayLog = fmt.Sprintf("%s/%04d-uat.log.gz", logDirectory, fileIndexNumber)
-		esReplayLog = fmt.Sprintf("%s/%04d-es.log.gz",logDirectory,fileIndexNumber)
+		esReplayLog = fmt.Sprintf("%s/%04d-es.log.gz", logDirectory, fileIndexNumber)
-		gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log.gz",logDirectory,fileIndexNumber)
+		gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log.gz", logDirectory, fileIndexNumber)
-		ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log.gz",logDirectory,fileIndexNumber)
+		ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log.gz", logDirectory, fileIndexNumber)
-		dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log.gz",logDirectory,fileIndexNumber)
+		dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log.gz", logDirectory, fileIndexNumber)
 	}
 }
 
@@ -562,9 +561,8 @@ func replayLog(msg string, msgclass int) {
 	if len(msg) == 0 { // Blank message.
 		return
 	}
-	var fp *os.File
+	var fp WriteCloser
-	var wt *gzip.Writer
+
-	if developerMode == true {	
 	switch msgclass {
 	case MSGCLASS_UAT:
 		fp = uatReplayWriter
@@ -577,28 +575,11 @@ func replayLog(msg string, msgclass int) {
 	case MSGCLASS_DUMP1090:
 		fp = dump1090ReplayWriter
 	}
+
 	if fp != nil {
 		s := makeReplayLogEntry(msg)
 		fp.Write([]byte(s))
 	}
-	} else {
-		switch msgclass {
-		case MSGCLASS_UAT:
-			wt = uatReplayWriterGzip
-		case MSGCLASS_ES:
-			wt = esReplayWriterGzip
-		case MSGCLASS_GPS:
-			wt = gpsReplayWriterGzip
-		case MSGCLASS_AHRS:
-			wt = ahrsReplayWriterGzip
-		case MSGCLASS_DUMP1090:
-			wt = dump1090ReplayWriterGzip
-		}
-		if wt != nil {
-			s := makeReplayLogEntry(msg)
-			wt.Write([]byte(s))
-		}
-	}
 }
 
 type WeatherMessage struct {
@@ -914,31 +895,26 @@ func replayMark(active bool) {
 
 }
 
-func openReplay(fn string) (*os.File, error) {
+func openReplay(fn string, compressed bool) (WriteCloser, 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
+	}
+
+	var ret WriteCloser
+	if compressed {
+		ret = gzip.NewWriter(fp) //FIXME: Close() on the gzip.Writer will not close the underlying file.
 	} else {
-		timeFmt := "Mon Jan 2 15:04:05 -0700 MST 2006"
+		ret = fp
-		fmt.Fprintf(fp, "START,%s,%s\n", timeStarted.Format(timeFmt), time.Now().Format(timeFmt)) // Start time marker.	
 	}
-	return fp, err
-}
 
-func openReplayGzip(fn string) (*gzip.Writer, 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
-	}
-	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.
-	gzw.Write([]byte(s))
+
-	return gzw, err
+	ret.Write([]byte(s))
+	return ret, err
 }
 
 func printStats() {
@@ -999,8 +975,6 @@ func uatReplay(f *os.File, replaySpeed uint64) {
 	uatReplayDone = true
 }
 
-
-
 func openReplayFile(fn string) *os.File {
 	f, err := os.Open(fn)
 	if err != nil {
@@ -1011,10 +985,9 @@ func openReplayFile(fn string) *os.File {
 	return f
 }
 
-
 func main() {
 
-//	replayESFilename := flag.String("eslog", "none", "ES Log filename")
+	//	replayESFilename := flag.String("eslog", "none", "ES Log filename")
 	replayUATFilename := flag.String("uatlog", "none", "UAT Log filename")
 	develFlag := flag.Bool("developer", false, "Developer mode")
 	replayFlag := flag.Bool("replay", false, "Replay file flag")
@@ -1027,7 +1000,7 @@ func main() {
 
 	if *develFlag == true {
 		log.Printf("Developer mode flag true!\n")
-	   developerMode=true
+		developerMode = true
 	}
 
 	// Duplicate log.* output to debugLog.
@@ -1048,9 +1021,9 @@ func main() {
 
 	crcInit() // Initialize CRC16 table.
 	if *replayFlag == true {
-//		if (*replayESFilename == "none") || (*replayUATFilename == "none") {
+		//		if (*replayESFilename == "none") || (*replayUATFilename == "none") {
-//			log.Fatal("Must specify both UAT and ES log files\n")
+		//			log.Fatal("Must specify both UAT and ES log files\n")
-//		}
+		//		}
 		log.Printf("Replay file %s\n", *replayUATFilename)
 	}
 
@@ -1063,78 +1036,41 @@ func main() {
 
 	// Set up the replay logs. Keep these files open in any case, even if replay logging is disabled.
 
-	// UAT replay log.
+	if uatwt, err := openReplay(uatReplayLog, !developerMode); err != nil {
-	if developerMode == true {
-		if uatwt, err := openReplay(uatReplayLog); err != nil {
 		globalSettings.ReplayLog = false
 	} else {
 		uatReplayWriter = uatwt
 		defer uatReplayWriter.Close()
 	}
 	// 1090ES replay log.
-		if eswt, err := openReplay(esReplayLog); err != nil {
+	if eswt, err := openReplay(esReplayLog, !developerMode); err != nil {
 		globalSettings.ReplayLog = false
 	} else {
 		esReplayWriter = eswt
 		defer esReplayWriter.Close()
 	}
 	// GPS replay log.
-		if gpswt, err := openReplay(gpsReplayLog); err != nil {
+	if gpswt, err := openReplay(gpsReplayLog, !developerMode); err != nil {
 		globalSettings.ReplayLog = false
 	} else {
 		gpsReplayWriter = gpswt
 		defer gpsReplayWriter.Close()
 	}
 	// AHRS replay log.
-		if ahrswt, err := openReplay(ahrsReplayLog); err != nil {
+	if ahrswt, err := openReplay(ahrsReplayLog, !developerMode); err != nil {
 		globalSettings.ReplayLog = false
 	} else {
 		ahrsReplayWriter = ahrswt
 		defer ahrsReplayWriter.Close()
 	}
 	// Dump1090 replay log.
-		if dump1090wt, err := openReplay(dump1090ReplayLog); err != nil {
+	if dump1090wt, err := openReplay(dump1090ReplayLog, !developerMode); err != nil {
 		globalSettings.ReplayLog = false
 	} else {
 		dump1090ReplayWriter = dump1090wt
 		defer dump1090ReplayWriter.Close()
 	}
-	} else {
+
-		if uatwt, err := openReplayGzip(uatReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			uatReplayWriterGzip = uatwt
-			defer uatReplayWriterGzip.Close()
-		}
-		// 1090ES replay log.
-		if eswt, err := openReplayGzip(esReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			esReplayWriterGzip = eswt
-			defer esReplayWriterGzip.Close()
-		}
-		// GPS replay log.
-		if gpswt, err := openReplayGzip(gpsReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			gpsReplayWriterGzip = gpswt
-			defer gpsReplayWriterGzip.Close()
-		}
-		// AHRS replay log.
-		if ahrswt, err := openReplayGzip(ahrsReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			ahrsReplayWriterGzip = ahrswt
-			defer ahrsReplayWriterGzip.Close()
-		}
-		// Dump1090 replay log.
-		if dump1090wt, err := openReplayGzip(dump1090ReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			dump1090ReplayWriterGzip = dump1090wt
-			defer dump1090ReplayWriterGzip.Close()
-		}
-	}
 	// Mark the files (whether we're logging or not).
 	replayMark(globalSettings.ReplayLog)
 
@@ -1158,16 +1094,16 @@ func main() {
 
 	if *replayFlag == true {
 		f := openReplayFile(*replayUATFilename)
-//		if len(os.Args) >= 4 {
+		//		if len(os.Args) >= 4 {
-//			i, err := strconv.ParseUint(os.Args[3], 10, 64)
+		//			i, err := strconv.ParseUint(os.Args[3], 10, 64)
-//			if err == nil {
+		//			if err == nil {
-//				replaySpeed = i
+		//				replaySpeed = i
-//			}
+		//			}
-//		}
+		//		}
 		playSpeed := uint64(*replaySpeed)
 		fmt.Fprintf(os.Stderr, "Replay speed: %dx\n", playSpeed)
 		go uatReplay(f, playSpeed)
-//		go esReplay(f2, playSpeed)
+		//		go esReplay(f2, playSpeed)
 		for {
 			time.Sleep(1 * time.Second)
 			if uatReplayDone {