From 495fb46feeb2c20bbf1e62e136c185910593fdc8 Mon Sep 17 00:00:00 2001 From: Christopher Young Date: Thu, 17 Dec 2015 16:11:17 -0500 Subject: [PATCH] Cleanup. --- main/gen_gdl90.go | 304 ++++++++++++++++++---------------------------- 1 file changed, 120 insertions(+), 184 deletions(-) diff --git a/main/gen_gdl90.go b/main/gen_gdl90.go index 6e1567bc..e9a90dda 100644 --- a/main/gen_gdl90.go +++ b/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 esReplayLog string -var gpsReplayLog string -var ahrsReplayLog string -var dump1090ReplayLog string +var uatReplayLog string +var esReplayLog string +var gpsReplayLog string +var ahrsReplayLog 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 uatReplayWriterGzip *gzip.Writer -var esReplayWriter *os.File -var esReplayWriterGzip *gzip.Writer -var gpsReplayWriter *os.File -var gpsReplayWriterGzip *gzip.Writer -var ahrsReplayWriter *os.File -var ahrsReplayWriterGzip *gzip.Writer -var dump1090ReplayWriter *os.File -var dump1090ReplayWriterGzip *gzip.Writer +var uatReplayWriter WriteCloser +var esReplayWriter WriteCloser +var gpsReplayWriter WriteCloser +var ahrsReplayWriter WriteCloser +var dump1090ReplayWriter WriteCloser 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) - if err != nil { - log.Printf("Unable to read index file %s using index of 0\n", indexFilename) - } - f.Close() - 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) + } + f.Close() + 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) - esReplayLog = fmt.Sprintf("%s/%04d-es.log",logDirectory,fileIndexNumber) - gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log",logDirectory,fileIndexNumber) - ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log",logDirectory,fileIndexNumber) - dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log",logDirectory,fileIndexNumber) + uatReplayLog = fmt.Sprintf("%s/%04d-uat.log", logDirectory, fileIndexNumber) + esReplayLog = fmt.Sprintf("%s/%04d-es.log", logDirectory, fileIndexNumber) + gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log", logDirectory, fileIndexNumber) + ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log", logDirectory, fileIndexNumber) + dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log", logDirectory, fileIndexNumber) } else { - uatReplayLog = fmt.Sprintf("%s/%04d-uat.log.gz",logDirectory,fileIndexNumber) - esReplayLog = fmt.Sprintf("%s/%04d-es.log.gz",logDirectory,fileIndexNumber) - gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log.gz",logDirectory,fileIndexNumber) - ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.log.gz",logDirectory,fileIndexNumber) - dump1090ReplayLog = fmt.Sprintf("%s/%04d-dump1090.log.gz",logDirectory,fileIndexNumber) + uatReplayLog = fmt.Sprintf("%s/%04d-uat.log.gz", logDirectory, fileIndexNumber) + esReplayLog = fmt.Sprintf("%s/%04d-es.log.gz", logDirectory, fileIndexNumber) + gpsReplayLog = fmt.Sprintf("%s/%04d-gps.log.gz", logDirectory, fileIndexNumber) + ahrsReplayLog = fmt.Sprintf("%s/%04d-ahrs.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 wt *gzip.Writer - if developerMode == true { - switch msgclass { - case MSGCLASS_UAT: - fp = uatReplayWriter - case MSGCLASS_ES: - fp = esReplayWriter - case MSGCLASS_GPS: - fp = gpsReplayWriter - case MSGCLASS_AHRS: - fp = ahrsReplayWriter - 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)) - } + var fp WriteCloser + + switch msgclass { + case MSGCLASS_UAT: + fp = uatReplayWriter + case MSGCLASS_ES: + fp = esReplayWriter + case MSGCLASS_GPS: + fp = gpsReplayWriter + case MSGCLASS_AHRS: + fp = ahrsReplayWriter + case MSGCLASS_DUMP1090: + fp = dump1090ReplayWriter + } + + if fp != nil { + s := makeReplayLogEntry(msg) + fp.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" - fmt.Fprintf(fp, "START,%s,%s\n", timeStarted.Format(timeFmt), time.Now().Format(timeFmt)) // Start time marker. + ret = fp } - 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") - developerMode=true + log.Printf("Developer mode flag true!\n") + 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") { -// log.Fatal("Must specify both UAT and ES log files\n") -// } + // if (*replayESFilename == "none") || (*replayUATFilename == "none") { + // 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 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 { - 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() - } + if uatwt, err := openReplay(uatReplayLog, !developerMode); err != nil { + globalSettings.ReplayLog = false } 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() - } + uatReplayWriter = uatwt + defer uatReplayWriter.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 { -// i, err := strconv.ParseUint(os.Args[3], 10, 64) -// if err == nil { -// replaySpeed = i -// } -// } + // 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) + // go esReplay(f2, playSpeed) for { time.Sleep(1 * time.Second) if uatReplayDone { - //&& esDone { + //&& esDone { return } } - + } else { for { buf, err := reader.ReadString('\n')