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"
@@ -31,7 +31,7 @@ const (
 	maxDatagramSize     = 8192
 	maxUserMsgQueueSize = 25000 // About 10MB per port per connected client.
 	logDirectory        = "/var/log/stratux"
-	
+
 	UPLINK_BLOCK_DATA_BITS  = 576
 	UPLINK_BLOCK_BITS       = (UPLINK_BLOCK_DATA_BITS + 160)
 	UPLINK_BLOCK_DATA_BYTES = (UPLINK_BLOCK_DATA_BITS / 8)
@@ -61,11 +61,11 @@ const (
 	TRACK_RESOLUTION   = float32(360.0 / 256.0)
 )
 
-var	uatReplayLog string
+var uatReplayLog string
-var	esReplayLog string
+var esReplayLog string
-var	gpsReplayLog string
+var gpsReplayLog string
-var	ahrsReplayLog string
+var ahrsReplayLog string
-var	dump1090ReplayLog string
+var dump1090ReplayLog string
 
 var stratuxBuild string
 var stratuxVersion string
@@ -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,49 +115,48 @@ 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 {
+		if err != nil {
-		log.Printf("Unable to read index file %s using index of 0\n", indexFilename)
+			log.Printf("Unable to read index file %s using index of 0\n", indexFilename)
-	  }
+		}
-	  f.Close()
+		f.Close()
-	  fileIndexNumber++
+		fileIndexNumber++
 	}
 	fo, err := os.Create(indexFilename)
 	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,42 +561,24 @@ 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 {
-		switch msgclass {
+	case MSGCLASS_UAT:
-		case MSGCLASS_UAT:
+		fp = uatReplayWriter
-			fp = uatReplayWriter
+	case MSGCLASS_ES:
-		case MSGCLASS_ES:
+		fp = esReplayWriter
-			fp = esReplayWriter
+	case MSGCLASS_GPS:
-		case MSGCLASS_GPS:
+		fp = gpsReplayWriter
-			fp = gpsReplayWriter
+	case MSGCLASS_AHRS:
-		case MSGCLASS_AHRS:
+		fp = ahrsReplayWriter
-			fp = ahrsReplayWriter
+	case MSGCLASS_DUMP1090:
-		case MSGCLASS_DUMP1090:
+		fp = dump1090ReplayWriter
-			fp = dump1090ReplayWriter
+	}
-		}
+
-		if fp != nil {
+	if fp != nil {
-			s := makeReplayLogEntry(msg)
+		s := makeReplayLogEntry(msg)
-			fp.Write([]byte(s))
+		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))
-		}
 	}
 }
 
@@ -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,25 +985,24 @@ 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")
 	replaySpeed := flag.Int("speed", 1, "Replay speed multiplier")
-	
+
 	flag.Parse()
-	
+
 	timeStarted = time.Now()
 	runtime.GOMAXPROCS(runtime.NumCPU()) // redundant with Go v1.5+ compiler
 
 	if *develFlag == true {
-	   log.Printf("Developer mode flag true!\n")
+		log.Printf("Developer mode flag true!\n")
-	   developerMode=true
+		developerMode = true
 	}
-	
+
 	// Duplicate log.* output to debugLog.
 	fp, err := os.OpenFile(debugLog, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 	if err != nil {
@@ -1042,18 +1015,18 @@ func main() {
 
 	log.Printf("Stratux %s (%s) starting.\n", stratuxVersion, stratuxBuild)
 	constructFilenames()
-	
+
 	ADSBTowers = make(map[string]ADSBTower)
 	MsgLog = make([]msg, 0)
 
 	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)
 	}
-	
+
 	sdrInit()
 	initTraffic()
 
@@ -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 {
+		globalSettings.ReplayLog = false
-		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 {
-			globalSettings.ReplayLog = false
-		} else {
-			esReplayWriter = eswt
-			defer esReplayWriter.Close()
-		}
-		// GPS replay log.
-		if gpswt, err := openReplay(gpsReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			gpsReplayWriter = gpswt
-			defer gpsReplayWriter.Close()
-		}
-		// AHRS replay log.
-		if ahrswt, err := openReplay(ahrsReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			ahrsReplayWriter = ahrswt
-			defer ahrsReplayWriter.Close()
-		}
-		// Dump1090 replay log.
-		if dump1090wt, err := openReplay(dump1090ReplayLog); err != nil {
-			globalSettings.ReplayLog = false
-		} else {
-			dump1090ReplayWriter = dump1090wt
-			defer dump1090ReplayWriter.Close()
-		}
 	} else {
-		if uatwt, err := openReplayGzip(uatReplayLog); err != nil {
+		uatReplayWriter = uatwt
-			globalSettings.ReplayLog = false
+		defer uatReplayWriter.Close()
-		} 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()
-		}
 	}
+	// 1090ES replay log.
+	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, !developerMode); err != nil {
+		globalSettings.ReplayLog = false
+	} else {
+		gpsReplayWriter = gpswt
+		defer gpsReplayWriter.Close()
+	}
+	// AHRS replay log.
+	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, !developerMode); err != nil {
+		globalSettings.ReplayLog = false
+	} else {
+		dump1090ReplayWriter = dump1090wt
+		defer dump1090ReplayWriter.Close()
+	}
+
 	// Mark the files (whether we're logging or not).
 	replayMark(globalSettings.ReplayLog)
 
@@ -1158,24 +1094,24 @@ 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 {
-			//&& esDone {
+				//&& esDone {
 				return
 			}
 		}
-	
+
 	} else {
 		for {
 			buf, err := reader.ReadString('\n')