updated the recorder gobngsdk v2

Reviewed-on: #2

.gitignore

@@ -1 +1,4 @@
 *.bin
+*.work*
+*.pprof
+*.log

README.md

@@ -12,7 +12,54 @@ without having to be playing the game while doing it (fans are noisy).
 
 # Usage
 To start replaying:
-`BeamNGMockOg replay -a 127.0.0.1 -p 4443 -i sunburstManual.bin`
+`telemetrymockserver beamng replay [--loop] -a 127.0.0.1 -p 4443 -i sunburstManual.bin`
+- `loop` allows the replay functionality to keep replaying the same data file
+
 
 To start recording:
-`BeamNGMockOg record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin`
+`BeamNGMockOg beamng record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin`
+
+## Development
+Use `tcpdump` to listen to the socket and check if data is coming through:
+`tcpdump -i any udp port <port> -X`
+
+### TODO:
+- [ ] Create the auto completion file and add it to `$FPATH`
+- [ ] Create a shortcut so we don't have to type out `telemetrymockserver` everytime
+
+
+### Benchmark
+Run with:
+`go test ./mockserver -bench=BenchmarkReplayAsync -benchmem -benchtime=1x -memprofile=mem.pprof`
+
+Analyze the output with:
+`go tool pprof -sample_index=alloc_objects mem.pprof` -> `top`
+- `ignore=net` will ignore the net package for example
+- `focus=mockserver` will show only the results from this code we are testing
+or
+`go tool pprof -http=:8080 mem.pprof`
+
+
+#### Previous results:
+Note: this were made before introducing the real time visualizer
+```
+goos: linux
+goarch: amd64
+pkg: github.com/ESilva15/BeamNGMockOg/mockserver
+cpu: AMD Ryzen 5 5600G with Radeon Graphics
+BenchmarkReplayAsync-12    	      1	109433931841 ns/op	 356088 B/op	  13272 allocs/op
+PASS
+ok  	github.com/ESilva15/BeamNGMockOg/mockserver	109.440s
+```
+
+
+#### Current results
+```
+goos: linux
+goarch: amd64
+pkg: github.com/ESilva15/BeamNGMockOg/mockserver
+cpu: AMD Ryzen 7 5800X3D 8-Core Processor
+BenchmarkReplayAsync-16    	      1	109433890158 ns/op	1673128 B/op	 112986 allocs/op
+PASS
+ok  	github.com/ESilva15/BeamNGMockOg/mockserver	109.439s
+```

cmd/beamng.go

@@ -0,0 +1,94 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+
+	beamng "github.com/ESilva15/TelemetryMockserver/internal/mockservers/beamng"
+
+	"github.com/spf13/cobra"
+)
+
+// beamNGCmd is the parent command for the BeamNG agent actions
+var beamNGCmd = &cobra.Command{
+	Use:   "beamng",
+	Short: "BeamNG telemetry utilities",
+	Args:  nil,
+}
+
+var beamNGRecordCMD = &cobra.Command{
+	Use:   "record",
+	Short: "record -o <path-to-output-file>",
+	Long: `record will store the data from the given UDP server to the 
+	filepath given by -o`,
+	Args: nil,
+	Run:  recordAction,
+}
+
+var beamNGReplayCMD = &cobra.Command{
+	Use:   "replay",
+	Short: "replay -i <path-to-input-file>",
+	Long:  "replay will replay the data on the given filepath on a UDP server",
+	Args:  nil,
+	Run:   replayAction,
+}
+
+func recordAction(cmd *cobra.Command, args []string) {
+	outputFile, _ := cmd.Flags().GetString("output")
+	address, _ := cmd.Flags().GetString("address")
+	port, _ := cmd.Flags().GetInt("port")
+
+	recorder, err := beamng.NewRecorder(outputFile, address, port)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create new BeamNG recorder: %+v", err))
+	}
+	defer recorder.Close()
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	if err := recorder.Record(ctx); err != nil {
+		fmt.Printf("Something went wrong while recording the file: %v", err)
+	}
+}
+
+func replayAction(cmd *cobra.Command, args []string) {
+	inputFile, _ := cmd.Flags().GetString("input")
+	address, _ := cmd.Flags().GetString("address")
+	port, _ := cmd.Flags().GetInt("port")
+	loop, _ := cmd.Flags().GetBool("loop")
+
+	replayer, err := beamng.NewReplayer(address, port, inputFile)
+	if err != nil {
+		slog.Error("Something went wrong setting up the player", "err", err)
+		return
+	}
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	err = replayer.Replay(ctx, loop)
+	if err != nil {
+		slog.Error("Something went wrong while playing the file", "err", err)
+		return
+	}
+}
+
+func init() {
+	// Beamng commnad flags
+	beamNGCmd.PersistentFlags().StringP("address", "a", "127.0.0.1", "Address for the UDP server")
+	beamNGCmd.MarkFlagRequired("address")
+	beamNGCmd.PersistentFlags().IntP("port", "p", 4444, "Port for the UDP server")
+	beamNGCmd.MarkFlagRequired("port")
+
+	// Record command flags
+	beamNGRecordCMD.Flags().StringP("output", "o", "output.bin", "output file for recording")
+	beamNGRecordCMD.MarkFlagRequired("output")
+
+	// Replay command flags
+	beamNGReplayCMD.Flags().BoolP("loop", "l", false, "whether to loop the recording")
+	beamNGReplayCMD.Flags().StringP("input", "i", "input.bin", "input file for reading")
+	beamNGReplayCMD.MarkFlagRequired("input")
+
+	rootCmd.AddCommand(beamNGCmd)
+	beamNGCmd.AddCommand(beamNGRecordCMD, beamNGReplayCMD)
+}

cmd/cmd.go

@@ -9,8 +9,8 @@ import (
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
-	Use:   "bngmock",
-	Short: "CLI for a BeamNG OG mockserver",
+	Use:   "telemetrymockserver",
+	Short: "CLI for mocking and recording data from different sources. Primarily for simracing",
 	Long:  ``,
 }
 

cmd/iracing.go

@@ -0,0 +1,54 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ESilva15/TelemetryMockserver/internal/mockservers/iracing"
+	"github.com/spf13/cobra"
+)
+
+// beamNGCmd is the parent command for the BeamNG agent actions
+var iracingCmd = &cobra.Command{
+	Use:   "iracing",
+	Short: "iRacing telemetry utility",
+	Args:  nil,
+}
+
+var iracingReplayCMD = &cobra.Command{
+	Use:   "replay",
+	Short: "replay -i <input-file> -o <output-memory-map-file>",
+	Long:  "replays the <input-file> in the <output-memory-map-file>",
+	Args:  nil,
+	Run:   iracingReplayAction,
+}
+
+func iracingReplayAction(cmd *cobra.Command, args []string) {
+	// We need to get the path of the ibt.file
+	// outputFile, _ := cmd.Flags().GetString("output")
+	// inputFile, _ := cmd.Flags().GetString("input")
+
+	replayer, err := iracing.NewReplayer("", "")
+	if err != nil {
+		fmt.Printf("Something went wrong setting up the player: %+v", err)
+		return
+	}
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	if err := replayer.Replay(ctx, false); err != nil {
+		fmt.Printf("Something went wrong while playing the file: %v", err)
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(iracingCmd)
+
+	iracingCmd.AddCommand(iracingReplayCMD)
+
+	// iracingReplayCMD flags
+	iracingReplayCMD.Flags().StringP("input", "i", "input.ibt", "input file")
+	// iracingReplayCMD.MarkFlagRequired("input")
+	iracingReplayCMD.Flags().StringP("output", "o", "memmap.file", "output memory mapped file")
+	// iracingReplayCMD.MarkFlagRequired("output")
+}

cmd/record.go

@@ -1,35 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/ESilva15/BeamNGMockOg/mockserver"
-
-	"github.com/spf13/cobra"
-)
-
-func recordAction(cmd *cobra.Command, args []string) {
-	outputFile, _ := cmd.Flags().GetString("output")
-	address, _ := cmd.Flags().GetString("address")
-	port, _ := cmd.Flags().GetInt("port")
-
-	if err := mockserver.Record(address, port, outputFile); err != nil {
-		fmt.Printf("Something went wrong while recording the file: %v", err)
-	}
-}
-
-// shelf
-var recordCmd = &cobra.Command{
-	Use:   "record",
-	Short: "record -o <path-to-bin-file>",
-	Long: `record will store the data from the given UDP server to the 
-	filepath given by -i`,
-	Args: nil,
-	Run:  recordAction,
-}
-
-func init() {
-	rootCmd.AddCommand(recordCmd)
-
-	recordCmd.PersistentFlags().StringP("output", "o", "output.bin", "output file for recording")
-}

cmd/replay.go

@@ -1,34 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/ESilva15/BeamNGMockOg/mockserver"
-
-	"github.com/spf13/cobra"
-)
-
-func replayAction(cmd *cobra.Command, args []string) {
-	inputFile, _ := cmd.Flags().GetString("input")
-	address, _ := cmd.Flags().GetString("address")
-	port, _ := cmd.Flags().GetInt("port")
-
-	if err := mockserver.Replay(address, port, inputFile); err != nil {
-		fmt.Printf("Something went wrong while playing the file: %v", err)
-	}
-}
-
-// shelf
-var replayCmd = &cobra.Command{
-	Use:   "replay",
-	Short: "replay -i <path-to-bin-file>",
-	Long:  `replay will replay the data on the given filepath on a UDP server`,
-	Args:  nil,
-	Run:   replayAction,
-}
-
-func init() {
-	rootCmd.AddCommand(replayCmd)
-
-	replayCmd.PersistentFlags().StringP("input", "i", "nofile.bin", "input file for serving")
-}

constants/constants.go

@@ -0,0 +1,3 @@
+package constants
+
+const ProgramName = "TelemetryMockserver"

go.mod

@@ -1,13 +1,17 @@
-module github.com/ESilva15/BeamNGMockOg
+module github.com/ESilva15/TelemetryMockserver
 
 go 1.23.2
 
 require (
-	github.com/ESilva15/gobngsdk v0.0.2
+	github.com/ESilva15/gobngsdk v2.2.0
+	github.com/ESilva15/goirsdk v0.3.0
 	github.com/spf13/cobra v1.10.1
 )
 
 require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,6 +1,10 @@
-github.com/ESilva15/gobngsdk v0.0.2 h1:N6stNOE14Wg80BAZMFu/Qd9Qa/J0DmExCfdPoDf7lco=
-github.com/ESilva15/gobngsdk v0.0.2/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw=
+github.com/ESilva15/gobngsdk v1.1.3 h1:CFaz2KjHKnBLrQuEN1QHOd1761cWM/rmTwLpSLrgbe4=
+github.com/ESilva15/gobngsdk v1.1.3/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw=
+github.com/ESilva15/goirsdk v0.3.0 h1:6D95Avq7chikGHwEUKh7Y/HaLHOWQ75Qxaz8oMDSfrw=
+github.com/ESilva15/goirsdk v0.3.0/go.mod h1:5borQbw+L4fe9b58JFHRHZwrzz0sMVAteuYbRnFOc0Q=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -8,5 +12,11 @@ github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
 github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/mockservers/beamng/record.go

@@ -0,0 +1,114 @@
+package mockserver
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/TelemetryMockserver/constants"
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+type recorderViewData struct {
+	TotalBytes int64
+	Og         bngsdk.Outgauge
+}
+
+type Recorder struct {
+	SDK *bngsdk.BeamNGSDK
+	// Views
+	mut         sync.RWMutex
+	viewDataMut sync.RWMutex
+	viewData    recorderViewData
+	viewCh      chan *recorderViewData
+}
+
+func NewRecorder(fp string, address string, port int) (*Recorder, error) {
+	var recorder Recorder
+	var err error
+
+	recorder.SDK, err = bngsdk.NewBngSDK(bngsdk.Options{
+		Logger:           slog.Default().With("SDK", "BeamNG"),
+		SourceType:       bngsdk.UDPData,
+		ImportUDPAddress: address,
+		ImportUDPPort:    port,
+		ExportData:       true,
+		ExportDataType:   bngsdk.BinaryFile,
+		ExportDataPath:   fp,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	recorder.viewData = recorderViewData{}
+	recorder.viewCh = make(chan *recorderViewData, 1)
+
+	return &recorder, nil
+}
+
+func (r *Recorder) Close() {
+	r.SDK.Close()
+}
+
+func (r *Recorder) view(ctx context.Context) {
+	var buf bytes.Buffer
+
+	buf.Grow(2048)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case viewData := <-r.viewCh:
+			buf.Reset()
+			buf.WriteString("\x1b[2J\x1b[H")
+			fmt.Fprintf(&buf, "\x1b]0;%s - Recording ", constants.ProgramName)
+			stringifyRecordingProgress(&buf, viewData.TotalBytes)
+			fmt.Fprintf(&buf, "\x07")
+
+			stringifyRecordingProgress(&buf, viewData.TotalBytes)
+			fmt.Fprintf(&buf, "\n\n")
+
+			r.viewDataMut.RLock()
+			stringifyOutgaugeData(&buf, &viewData.Og)
+			r.viewDataMut.RUnlock()
+
+			_, _ = buf.WriteTo(os.Stdout)
+		}
+	}
+}
+
+// Record records data from the UDP connection created by address and port
+func (r *Recorder) Record(ctx context.Context) error {
+	ticker := time.NewTicker(time.Second / 60)
+	defer ticker.Stop()
+
+	go r.view(ctx)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-ticker.C:
+			og, err := r.SDK.Update()
+			if err != nil {
+				return err
+			}
+
+			r.viewData.TotalBytes = r.SDK.GetTotalWritten()
+			r.viewData.Og = *og
+
+			// Send the data to the view
+			select {
+			case r.viewCh <- &r.viewData:
+				// Sent the data
+			default:
+				// Dropped the frame!
+			}
+		}
+	}
+}

internal/mockservers/beamng/replay.go

@@ -0,0 +1,124 @@
+// Package mockserver is the core of this program and it will have the API
+// to record binary data from the UDP server and then be able to mock it
+package mockserver
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"math"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/TelemetryMockserver/constants"
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+type ViewData struct {
+	Outgauge bngsdk.Outgauge
+	SizeRead int64
+	FileSize int64
+}
+
+// Replayer does the replaying
+// Should we make a "player" struct that can record and replay?
+type Replayer struct {
+	SDK *bngsdk.BeamNGSDK
+
+	// Streams
+	dataViewCh chan ViewData
+
+	// Mut
+	mut sync.RWMutex
+
+	// View
+	viewData ViewData
+}
+
+func NewReplayer(address string, port int, fp string) (*Replayer, error) {
+	sdk, err := bngsdk.NewBngSDK(bngsdk.Options{
+		Logger:           slog.Default().With("SDK", "BeamNG"),
+		SourceType:       bngsdk.BinaryFile,
+		BinSourcePath:    fp,
+		ExportData:       true,
+		ExportDataType:   bngsdk.UDPData,
+		ExportUDPAddress: address,
+		ExportUDPPort:    port,
+		Loop:             true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	replayer := &Replayer{
+		SDK:        sdk,
+		dataViewCh: make(chan ViewData, 1),
+	}
+
+	return replayer, nil
+}
+
+// renderToTerminal will render the data for the users viewing pleasure
+func (r *Replayer) renderToTerminal(ctx context.Context) {
+	var buf bytes.Buffer
+	buf.Grow(2048)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case data := <-r.dataViewCh:
+			// Reset to the start of the terminal
+			// percent := int(float64(data.SizeRead) / float64(data.FileSize) * 100)
+			percent := int(math.Round((float64(data.SizeRead) / float64(data.FileSize)) * 100))
+
+			buf.Reset()
+			buf.WriteString("\x1b[2J\x1b[H")
+			fmt.Fprintf(&buf, "\x1b]0;%s - Replaying %d%%\x07", constants.ProgramName, percent)
+
+			fmt.Fprintf(&buf, "Replayed: %d%%\n", percent)
+
+			stringifyOutgaugeData(&buf, &data.Outgauge)
+
+			buf.WriteTo(os.Stdout)
+		}
+	}
+}
+
+// Replay replays a given file <fp> in a UDP server <addr>:<port>
+func (r *Replayer) Replay(ctx context.Context, loop bool) error {
+	go r.renderToTerminal(ctx)
+
+	ticker := time.NewTicker(time.Second / 60)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+
+		case <-ticker.C:
+			og, err := r.SDK.Update()
+			if err != nil {
+				// TODO: log here
+				slog.Error("an error occurred when updating", "err", err)
+				return err
+			}
+
+			r.mut.Lock()
+			r.viewData.SizeRead = r.SDK.GetTotalRead()
+			r.viewData.FileSize = r.SDK.GetSourceSize()
+			r.viewData.Outgauge = *og
+			r.mut.Unlock()
+
+			// Send the data to the view
+			select {
+			case r.dataViewCh <- r.viewData:
+				// Sent the data
+			default:
+				// Dropped the frame!
+			}
+		}
+	}
+}

internal/mockservers/beamng/replay_test.go

@@ -0,0 +1,64 @@
+package mockserver
+
+import (
+	"context"
+	"net"
+	"os"
+	"testing"
+)
+
+func BenchmarkReplayAsync(b *testing.B) {
+	// Dummy socket
+	addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
+	if err != nil {
+		b.Fatalf("failed to resolve UDP address: %v", err)
+	}
+
+	listener, err := net.ListenUDP("udp", addr)
+	if err != nil {
+		b.Fatalf("failed to start background UDP listener: %v", err)
+	}
+	defer listener.Close()
+
+	// Drain the socket
+	go func() {
+		buf := make([]byte, 65535)
+		for {
+			_, _, err := listener.ReadFrom(buf)
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	// Extract the random port assigned by the OS
+	assignedAddr := listener.LocalAddr().(*net.UDPAddr)
+
+	// Get the file path
+	filePath := "sunburstManual.bin"
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		filePath = "../" + filePath
+	}
+
+	// Reset the timer
+	b.ResetTimer()
+
+	// Benchmark loop
+	for i := 0; i < b.N; i++ {
+		ctx, cancel := context.WithCancel(context.Background())
+
+		replayer, err := NewReplayer(assignedAddr.IP.String(), assignedAddr.Port, filePath)
+		if err != nil {
+			cancel()
+			b.Fatalf("Error setting up replayer: %+v", err)
+		}
+
+		err = replayer.Replay(ctx, false)
+		if err != nil {
+			cancel()
+			b.Fatalf("Replay failed during benchmark run: %+v", err)
+		}
+
+		cancel()
+	}
+}

internal/mockservers/beamng/views.go

@@ -0,0 +1,89 @@
+package mockserver
+
+import (
+	"bytes"
+	"fmt"
+
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+const (
+	_   = iota
+	KiB = 1 << (10 * iota)
+	MiB
+	GiB
+)
+
+func stringifyRecordingProgress(s *bytes.Buffer, nBytes int64) {
+	if nBytes < KiB {
+		fmt.Fprintf(s, "%d B", nBytes)
+	} else if nBytes < MiB {
+		fmt.Fprintf(s, "%.2f KiB", float64(nBytes)/float64(KiB))
+	} else if nBytes < GiB {
+		fmt.Fprintf(s, "%.2f MiB", float64(nBytes)/float64(MiB))
+	} else {
+		fmt.Fprintf(s, "%.2f GiB", float64(nBytes)/float64(GiB))
+	}
+}
+
+func stringifyOutgaugeData(s *bytes.Buffer, og *bngsdk.Outgauge) {
+	// NOTE: write a string serialization function on the SDK itself
+	fmt.Fprint(s, "Outgauge {\n")
+	fmt.Fprintf(s, "  Time:        %d ms\n", og.Time)
+	fmt.Fprintf(s, "  Car:         %s\n", og.Car)
+	fmt.Fprintf(s, "  Flags:       %b\n", og.Flags)
+	fmt.Fprintf(s, "  Gear:        %d\n", og.Gear)
+	fmt.Fprintf(s, "  Plid:        %d\n", og.Plid)
+	fmt.Fprintf(s, "  Speed:       %f m/s\n", og.Speed)
+	fmt.Fprintf(s, "  RPM:         %f RPM\n", og.RPM)
+	fmt.Fprintf(s, "  Turbo:       %f Bar\n", og.Turbo)
+	fmt.Fprintf(s, "  EngTemp:     %f °C\n", og.EngTemp)
+	fmt.Fprintf(s, "  Fuel:        %f\n", og.Fuel)
+	fmt.Fprintf(s, "  OilPressure: %f Bar\n", og.OilPressure)
+	fmt.Fprintf(s, "  OilTemp:     %f °C\n", og.OilTemp)
+	fmt.Fprintf(s, "  DashLights:  %b\n", og.DashLights)
+	fmt.Fprintf(s, "  ShowLights:  %b\n", og.ShowLights)
+	fmt.Fprintf(s, "  Throttle:    %f\n", og.Throttle)
+	fmt.Fprintf(s, "  Brakes:      %f\n", og.Brake)
+	fmt.Fprintf(s, "  Clutch:      %f\n", og.Clutch)
+	fmt.Fprintf(s, "  Display1:    %s\n", og.Display1)
+	fmt.Fprintf(s, "  Display2:    %s\n", og.Display2)
+	fmt.Fprintf(s, "  ID:          %d\n", og.ID)
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "DashLights {\n")
+	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", og.HasShiftLight())
+	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", og.HasHighBeamLight())
+	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", og.HasHandbrakeLight())
+	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", og.HasPitspeed())
+	fmt.Fprintf(s, "  DL_TC:         %t\n", og.HasTractionControlLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", og.HasLeftIndicatorLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", og.HasRightIndicatorLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", og.HasAnyIndicatorLight())
+	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", og.HasOilLight())
+	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", og.HasBatteryLight())
+	fmt.Fprintf(s, "  DL_ABS:        %t\n", og.HasABSLight())
+	fmt.Fprintf(s, "  DL_SPARE:      %t\n", og.HasSpare())
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "ShowLights {\n") // Fixed typo "ShowLigths"
+	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", og.ShiftLight())
+	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", og.HighBeam())
+	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", og.Handbrake())
+	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", og.Pitspeed())
+	fmt.Fprintf(s, "  DL_TC:         %t\n", og.TractionControl())
+	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", og.LeftIndicator())
+	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", og.RightIndicator())
+	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", og.AnyIndicator())
+	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", og.OilLight())
+	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", og.BatteryLight())
+	fmt.Fprintf(s, "  DL_ABS:        %t\n", og.ABS())
+	fmt.Fprintf(s, "  DL_SPARE:      %t\n", og.Spare())
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "Flags {\n")
+	fmt.Fprintf(s, "  OG_TURBO (Has Turbo): %t\n", og.HasTurbo())
+	fmt.Fprintf(s, "  OG_KM (Is Metric):    %t\n", og.PrefersKm())
+	fmt.Fprintf(s, "  OG_BAR (Pressure):    %t\n", og.PrefersBAR())
+	fmt.Fprint(s, "}")
+}

internal/mockservers/iracing/replay.go

@@ -0,0 +1,94 @@
+package iracing
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/goirsdk"
+)
+
+type Replayer struct {
+	SDK *goirsdk.IBT
+	// DataSourcePath string
+	// Socket         *UDPTransport
+
+	// Output memory mapped file
+	outputMmap string
+
+	// Streams
+	// dataViewCh chan ViewData
+	// socketCh   chan []byte
+
+	// Mut
+	mut sync.RWMutex
+
+	// View
+	// viewData ViewData
+}
+
+func NewReplayer(input string, output string) (*Replayer, error) {
+	ibt, err := goirsdk.Init(goirsdk.Options{
+		Logger:        slog.Default(),
+		SourceType:    goirsdk.IBTFile,
+		SourcePath:    "../testTelemetry/gt3_mustang_bathurst.ibt",
+		IBTExportType: goirsdk.SharedMemoryFile,
+		IBTExport:     true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	replayer := &Replayer{
+		SDK: ibt,
+	}
+
+	return replayer, nil
+}
+
+func (r *Replayer) Replay(ctx context.Context, loop bool) error {
+	mainLoopTicker := time.NewTicker(time.Second / 240)
+	defer mainLoopTicker.Stop()
+
+	for {
+		// Update the data that the SDK is holding with the next tick
+		_, err := r.SDK.Update(100 * time.Millisecond)
+		if err != nil {
+			log.Printf("could not update data: %v", err)
+			continue
+		}
+
+		// Vehicle Movement data gathered from the names we can find on the
+		// telemetry_docs.pdf file
+		// - I wish to make this less verbose if possible
+		if _, ok := r.SDK.Vars.Vars["Gear"]; !ok {
+			log.Fatal("Field `Gear` doesn't exist")
+		}
+
+		if _, ok := r.SDK.Vars.Vars["RPM"]; !ok {
+			log.Fatal("Field `RPM` doesn't exist")
+		}
+
+		if _, ok := r.SDK.Vars.Vars["Speed"]; !ok {
+			log.Fatal("Field `Speed` doesn't exist")
+		}
+
+		gear := int32(r.SDK.Vars.Vars["Gear"].Value.(int))
+		rpm := int32(r.SDK.Vars.Vars["RPM"].Value.(float32))
+		speed := int32(r.SDK.Vars.Vars["Speed"].Value.(float32))
+		sessionState := r.SDK.Vars.Vars["SessionState"].Value.(int)
+
+		fmt.Printf("\033[?25l\033[2J\033[H")
+		fmt.Printf("Gear: %d, RPM: %d, Speed: %d\n", gear, rpm, speed)
+		fmt.Printf("\n")
+		fmt.Printf("IsConnected: %t\n", r.SDK.IsConnected())
+		fmt.Printf("  SessionStatusConnected: %t\n", r.SDK.SessionStatusConnected())
+		fmt.Printf("  SessionStatusInvalid:   %t\n", r.SDK.SessionStateInvalid())
+		fmt.Printf("  SessionState:           %d\n", sessionState)
+
+		<-mainLoopTicker.C
+	}
+}

internal/mockservers/mockserver.go

@@ -0,0 +1,10 @@
+// Package mockservers defines the available mockserver for the telemetry data
+package mockservers
+
+import "context"
+
+// Mockserver defines what a mockserver should do
+type Mockserver interface {
+	Replay(context.Context, bool)
+	Record(output string)
+}

main.go

@@ -1,6 +1,32 @@
 package main
 
-import "github.com/ESilva15/BeamNGMockOg/cmd"
+import (
+	"log/slog"
+	"os"
+
+	"github.com/ESilva15/TelemetryMockserver/cmd"
+)
+
+func init() {
+	_ = setupLogger()
+}
+
+func setupLogger() error {
+	output, err := os.OpenFile("./output.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o755)
+	if err != nil {
+		return err
+	}
+
+	logger := slog.New(
+		slog.NewTextHandler(output, &slog.HandlerOptions{
+			Level: slog.LevelDebug,
+		}),
+	)
+
+	slog.SetDefault(logger)
+
+	return nil
+}
 
 func main() {
 	cmd.Execute()

mockserver/record.go

@@ -1,41 +0,0 @@
-package mockserver
-
-import (
-	"encoding/gob"
-	"log"
-	"os"
-	"time"
-
-	bngsdk "github.com/ESilva15/gobngsdk"
-)
-
-// Record records data from the UDP connection created by address and port
-func Record(address string, port int, filePath string) error {
-	ticker := time.NewTicker(time.Second / 60)
-	defer ticker.Stop()
-
-	// Create the output file
-	bin, err := os.Create(filePath)
-	if err != nil {
-		return err
-	}
-
-	// Create the BeamNGSDK instance
-	beam, err := bngsdk.Init(address, port)
-	if err != nil {
-		return err
-	}
-	defer beam.Close()
-
-	enc := gob.NewEncoder(bin)
-	for {
-		err := beam.ReadData()
-		if err != nil {
-			return err
-		}
-		if err := enc.Encode(beam.Data); err != nil {
-			log.Fatal(err)
-		}
-		<-ticker.C
-	}
-}

mockserver/replay.go

@@ -1,54 +0,0 @@
-// Package mockserver is the core of this program and it will have the API
-// to record binary data from the UDP server and then be able to mock it
-package mockserver
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/gob"
-	"log"
-	"os"
-	"time"
-
-	sdk "github.com/ESilva15/gobngsdk"
-)
-
-// Replay replays a given file <fp> in a UDP server <addr>:<port>
-func Replay(address string, port int, fp string) error {
-	bin, err := os.Open(fp)
-	if err != nil {
-		log.Fatal("error opening file:", err)
-	}
-
-	udp, err := newUDPServer(address, port)
-	if err != nil {
-		return err
-	}
-
-	ticker := time.NewTicker(time.Second / 60)
-	defer ticker.Stop()
-
-	dec := gob.NewDecoder(bin)
-	for {
-		var og sdk.Outgauge
-		if err := dec.Decode(&og); err != nil {
-			log.Fatal("failed to read more data:", err)
-			break
-		}
-
-		buf := new(bytes.Buffer)
-		if err := binary.Write(buf, binary.LittleEndian, &og); err != nil {
-			log.Fatal("serialization failed:", err)
-			break
-		}
-
-		if _, err := udp.Conn.WriteToUDP(buf.Bytes(), udp.Addr); err != nil {
-			log.Fatal("send failed:", err)
-			break
-		}
-
-		<-ticker.C
-	}
-
-	return udp.Close()
-}

mockserver/server.go

@@ -1,29 +0,0 @@
-package mockserver
-
-import (
-	"fmt"
-	"net"
-)
-
-type udpServer struct {
-	Addr *net.UDPAddr
-	Conn *net.UDPConn
-}
-
-func newUDPServer(addr string, port int) (udpServer, error) {
-	udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", addr, port))
-	if err != nil {
-		return udpServer{}, err
-	}
-
-	conn, err := net.ListenUDP("udp", nil)
-	if err != nil {
-		return udpServer{}, err
-	}
-
-	return udpServer{Addr: udpAddr, Conn: conn}, nil
-}
-
-func (u *udpServer) Close() error {
-	return u.Conn.Close()
-}