Compare commits

...
14 Commits
21 changed files with 560 additions and 515 deletions
+2
View File
@@ -1,2 +1,4 @@
*.bin *.bin
*.work* *.work*
*.pprof
*.log
+17 -8
View File
@@ -1,28 +1,37 @@
# BeamNGMockOG # TelemetryMockserver
Utility to both record (with the caveat that it doesn't record yet) and replay Utility to both record and replay telemetry data from multiple simulators.
binary data relating to the Outgauge struct of beamng.
This will help me develop some stuff I'm doing for `ESDI` and my peripherals This will help me develop some stuff I'm doing for `ESDI` and my peripherals
without having to be playing the game while doing it (fans are noisy). without having to be playing the game while doing it (fans are noisy).
## Related projects
- [ESDI](https://github.com/ESilva15/ESDI)
- [iRacing Go SDK](https://github.com/ESilva15/goirsdk)
- [BeamNG Go SDK](https://github.com/ESilva15/gobngsdk)
# Installation # Installation
`go install github.com/ESilva15/BeamNGMockOg@latest` `go install github.com/ESilva15/TelemetryMockserver@latest`
# Usage # Usage
To start replaying: To start replaying (BeamNG as an example):
`BeamNGMockOg replay [--loop] -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 - `loop` allows the replay functionality to keep replaying the same data file
To start recording: To start recording (BeamNG as an example):
`BeamNGMockOg record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin` `TelemetryMockserver beamng record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin`
## Development ## Development
Use `tcpdump` to listen to the socket and check if data is coming through: Use `tcpdump` to listen to the socket and check if data is coming through:
`tcpdump -i any udp port <port> -X` `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 ### Benchmark
Run with: Run with:
+94
View File
@@ -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)
}
+2 -2
View File
@@ -9,8 +9,8 @@ import (
// rootCmd represents the base command when called without any subcommands // rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{ var rootCmd = &cobra.Command{
Use: "bngmock", Use: "telemetrymockserver",
Short: "CLI for a BeamNG OG mockserver", Short: "CLI for mocking and recording data from different sources. Primarily for simracing",
Long: ``, Long: ``,
} }
+54
View File
@@ -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")
}
-44
View File
@@ -1,44 +0,0 @@
package cmd
import (
"context"
"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")
recorder, err := mockserver.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)
}
}
// 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")
}
-45
View File
@@ -1,45 +0,0 @@
package cmd
import (
"context"
"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")
loop, _ := cmd.Flags().GetBool("loop")
replayer, err := mockserver.NewReplayer(address, port, inputFile)
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, loop); 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")
replayCmd.PersistentFlags().BoolP("loop", "l", false, "loop replay after finishing")
}
+3
View File
@@ -0,0 +1,3 @@
package constants
const ProgramName = "TelemetryMockserver"
+9 -2
View File
@@ -1,13 +1,20 @@
module github.com/ESilva15/BeamNGMockOg module github.com/ESilva15/TelemetryMockserver
go 1.23.2 go 1.23.2
require ( require (
github.com/ESilva15/gobngsdk v1.1.1 github.com/ESilva15/gobngsdk v1.2.0
github.com/ESilva15/goirsdk v0.3.8
github.com/spf13/cobra v1.10.1 github.com/spf13/cobra v1.10.1
) )
require ( require (
github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/spf13/pflag v1.0.9 // 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
) )
//
// replace github.com/ESilva15/goirsdk => ../pkg/goirsdk/
// replace github.com/ESilva15/gobngsdk => ../pkg/gobngsdk/
+12 -2
View File
@@ -1,6 +1,10 @@
github.com/ESilva15/gobngsdk v1.1.1 h1:MyKUjIqG77lYcUY6cnZpnnxPoxS/FdAYwGoi6InXan0= github.com/ESilva15/gobngsdk v1.2.0 h1:jX2ByFaIHnjCdPmrj1JiqCoNRLyu4vqIXC7++EUOCK4=
github.com/ESilva15/gobngsdk v1.1.1/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw= github.com/ESilva15/gobngsdk v1.2.0/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw=
github.com/ESilva15/goirsdk v0.3.8 h1:Eiabg4TqMkJQCImLEqwN93/BAuafbYyTrNXxg/Ck9bQ=
github.com/ESilva15/goirsdk v0.3.8/go.mod h1:5borQbw+L4fe9b58JFHRHZwrzz0sMVAteuYbRnFOc0Q=
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= 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 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= 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/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 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= 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/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= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -3,82 +3,59 @@ package mockserver
import ( import (
"bytes" "bytes"
"context" "context"
"encoding/binary"
"fmt" "fmt"
"log/slog"
"os" "os"
"sync" "sync"
"time" "time"
"github.com/ESilva15/TelemetryMockserver/constants"
bngsdk "github.com/ESilva15/gobngsdk" bngsdk "github.com/ESilva15/gobngsdk"
) )
type recorderViewData struct { type recorderViewData struct {
TotalBytes int TotalBytes int64
SDK *bngsdk.BeamNGSDK Og bngsdk.Outgauge
} }
type Recorder struct { type Recorder struct {
SDK bngsdk.BeamNGSDK SDK *bngsdk.BeamNGSDK
OutputFile *os.File
TotalBytes int
// Views // Views
mut sync.RWMutex mut sync.RWMutex
viewDataMut sync.RWMutex viewDataMut sync.RWMutex
viewData recorderViewData viewData recorderViewData
viewCh chan *recorderViewData viewCh chan *recorderViewData
recorderCh chan []byte
} }
func NewRecorder(fp string, address string, port int) (*Recorder, error) { func NewRecorder(fp string, address string, port int) (*Recorder, error) {
var recorder Recorder var recorder Recorder
var err error var err error
recorder.SDK, err = bngsdk.Init(address, port) 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 { if err != nil {
return &Recorder{}, err return nil, err
}
recorder.OutputFile, err = os.Create(fp)
if err != nil {
return &Recorder{}, err
} }
recorder.viewData = recorderViewData{} recorder.viewData = recorderViewData{}
recorder.viewCh = make(chan *recorderViewData, 1) recorder.viewCh = make(chan *recorderViewData, 1)
recorder.recorderCh = make(chan []byte, 1)
return &recorder, nil return &recorder, nil
} }
func (r *Recorder) Close() { func (r *Recorder) Close() {
r.SDK.Close() r.SDK.Close()
if r.OutputFile != nil {
r.OutputFile.Close()
}
}
func (r *Recorder) record(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case data := <-r.recorderCh:
r.mut.Lock()
err := binary.Write(r.OutputFile, binary.LittleEndian, r.SDK.Data)
r.TotalBytes += len(data)
r.mut.Unlock()
if err != nil {
// NOTE: find a way of logging this somehow
}
}
}
} }
func (r *Recorder) view(ctx context.Context) { func (r *Recorder) view(ctx context.Context) {
var buf bytes.Buffer var buf bytes.Buffer
var nBytes int
buf.Grow(2048) buf.Grow(2048)
@@ -89,13 +66,15 @@ func (r *Recorder) view(ctx context.Context) {
case viewData := <-r.viewCh: case viewData := <-r.viewCh:
buf.Reset() buf.Reset()
buf.WriteString("\x1b[2J\x1b[H") 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, nBytes) stringifyRecordingProgress(&buf, viewData.TotalBytes)
fmt.Fprintf(&buf, "\n\n") fmt.Fprintf(&buf, "\n\n")
r.viewDataMut.RLock() r.viewDataMut.RLock()
nBytes = viewData.TotalBytes stringifyOutgaugeData(&buf, &viewData.Og)
stringifyOutgaugeData(&buf, &r.SDK)
r.viewDataMut.RUnlock() r.viewDataMut.RUnlock()
_, _ = buf.WriteTo(os.Stdout) _, _ = buf.WriteTo(os.Stdout)
@@ -108,7 +87,6 @@ func (r *Recorder) Record(ctx context.Context) error {
ticker := time.NewTicker(time.Second / 60) ticker := time.NewTicker(time.Second / 60)
defer ticker.Stop() defer ticker.Stop()
go r.record(ctx)
go r.view(ctx) go r.view(ctx)
for { for {
@@ -116,12 +94,13 @@ func (r *Recorder) Record(ctx context.Context) error {
case <-ctx.Done(): case <-ctx.Done():
return nil return nil
case <-ticker.C: case <-ticker.C:
err := r.SDK.ReadData() og, err := r.SDK.Update()
if err != nil { if err != nil {
return err return err
} }
r.viewData.TotalBytes = r.TotalBytes r.viewData.TotalBytes = r.SDK.GetTotalWritten()
r.viewData.Og = *og
// Send the data to the view // Send the data to the view
select { select {
@@ -130,14 +109,6 @@ func (r *Recorder) Record(ctx context.Context) error {
default: default:
// Dropped the frame! // Dropped the frame!
} }
// Write the data to the file
select {
case r.recorderCh <- r.SDK.Buffer:
// Sent the data
default:
// Dropped the frame!
}
} }
} }
} }
+124
View File
@@ -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!
}
}
}
}
+89
View File
@@ -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, "}")
}
+94
View File
@@ -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
}
}
+10
View File
@@ -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)
}
+27 -1
View File
@@ -1,6 +1,32 @@
package main 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() { func main() {
cmd.Execute() cmd.Execute()
-45
View File
@@ -1,45 +0,0 @@
package mockserver
import (
"io"
"unsafe"
sdk "github.com/ESilva15/gobngsdk"
)
type GobReader struct {
TotalRead int64
File io.ReadSeeker
Buf []byte
}
func NewGobReader(r io.ReadSeeker) *GobReader {
return &GobReader{
TotalRead: 0,
File: r,
Buf: make([]byte, unsafe.Sizeof(sdk.Outgauge{})),
}
}
func (g *GobReader) Reset() error {
_, err := g.File.Seek(0, io.SeekStart)
if err != nil {
return err
}
g.TotalRead = 0
return nil
}
func (g *GobReader) Next(buffer []byte) error {
_, err := io.ReadFull(g.File, buffer)
if err != nil {
return err
}
pos, _ := g.File.Seek(0, io.SeekCurrent)
g.TotalRead = pos
return nil
}
-186
View File
@@ -1,186 +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"
"context"
"encoding/binary"
"fmt"
"io"
"os"
"sync"
"time"
"unsafe"
bngsdk "github.com/ESilva15/gobngsdk"
)
type ViewData struct {
SDK *bngsdk.BeamNGSDK
SizeRead int64
}
// Replayer does the replaying
// Should we make a "player" struct that can record and replay?
type Replayer struct {
SDK bngsdk.BeamNGSDK
DataSourcePath string
Socket *UDPTransport
// Streams
dataViewCh chan ViewData
socketCh chan []byte
// Mut
mut sync.RWMutex
// View
viewData ViewData
}
func NewReplayer(address string, port int, fp string) (*Replayer, error) {
udp, err := NewUDPTransport(address, port)
if err != nil {
return nil, err
}
replayer := &Replayer{
DataSourcePath: fp,
SDK: bngsdk.BeamNGSDK{
Data: &bngsdk.Outgauge{},
Buffer: make([]byte, unsafe.Sizeof(bngsdk.Outgauge{})),
},
Socket: udp,
viewData: ViewData{},
dataViewCh: make(chan ViewData, 1),
socketCh: make(chan []byte, 1),
}
return replayer, nil
}
// renderToTerminal will render the data for the users viewing pleasure
func (r *Replayer) renderToTerminal(ctx context.Context) {
fileInfo, err := os.Stat(r.DataSourcePath)
if err != nil {
// NOTE: learn how to handle this error
// return fmt.Errorf("error stating file: %v", err)
}
var buf bytes.Buffer
var bytesReader bytes.Reader
buf.Grow(2048)
for {
select {
case <-ctx.Done():
return
case data := <-r.dataViewCh:
// Reset to the start of the terminal
buf.Reset()
buf.WriteString("\x1b[2J\x1b[H")
bytesReader.Reset(data.SDK.Buffer)
err := binary.Read(&bytesReader, binary.LittleEndian, r.SDK.Data)
if err != nil {
fmt.Fprintf(&buf, "FAILED TO PARSE DATA\nError: %+v", err)
_, _ = buf.WriteTo(os.Stdout)
continue
}
percent := int(float64(data.SizeRead) / float64(fileInfo.Size()) * 100)
fmt.Fprintf(&buf, "Replayed: %d%%\n", percent)
stringifyOutgaugeData(&buf, data.SDK)
buf.WriteTo(os.Stdout)
}
}
}
// writeToUDPSocket will write the telemetry data to the UDP socket
func (r *Replayer) writeToUDPSocket(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case data := <-r.socketCh:
r.mut.RLock()
_, err := r.Socket.Send(data)
r.mut.RUnlock()
if err != nil {
panic(fmt.Sprintf("error writing buffer to socket: %+v", err))
continue
// NOTE: log the error somewhere maybe
// return err
}
}
}
}
// Replay replays a given file <fp> in a UDP server <addr>:<port>
func (r *Replayer) Replay(ctx context.Context, loop bool) error {
bin, err := os.Open(r.DataSourcePath)
if err != nil {
return fmt.Errorf("error opening file: %v", err)
}
reader := NewGobReader(bin)
go r.renderToTerminal(ctx)
go r.writeToUDPSocket(ctx)
ticker := time.NewTicker(time.Second / 60)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-ticker.C:
r.mut.Lock()
err := reader.Next(r.SDK.Buffer)
r.mut.Unlock()
if err == io.EOF {
if !loop {
return r.Socket.Close()
}
err = reader.Reset()
if err != nil {
return err
}
continue
}
if err != nil {
return err
}
// NOTE: Really like this???
r.viewData.SDK = &r.SDK
r.viewData.SizeRead = reader.TotalRead
// Send the data to the view
select {
case r.dataViewCh <- r.viewData:
// Sent the data
default:
// Dropped the frame!
}
// Send the data to the UDP socket
select {
case r.socketCh <- r.SDK.Buffer:
// Sent the data
default:
// Dropped the frame!
}
}
}
}
-39
View File
@@ -1,39 +0,0 @@
package mockserver
import (
"fmt"
"net"
)
type Transport interface {
Send(data []byte) error
Close() error
}
type UDPTransport struct {
Conn *net.UDPConn
Addr *net.UDPAddr
}
func NewUDPTransport(address string, port int) (*UDPTransport, error) {
addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", address, port))
if err != nil {
return nil, err
}
conn, err := net.ListenUDP("udp", nil)
if err != nil {
return nil, err
}
return &UDPTransport{Conn: conn, Addr: addr}, nil
}
// Send will send a byte array of data trough the UDP server
func (u *UDPTransport) Send(data []byte) (int, error) {
return u.Conn.WriteToUDP(data, u.Addr)
}
func (u *UDPTransport) Close() error {
return u.Conn.Close()
}
-89
View File
@@ -1,89 +0,0 @@
package mockserver
import (
"bytes"
"fmt"
bngsdk "github.com/ESilva15/gobngsdk"
)
const (
_ = iota
KiB = 1 << (10 * iota)
MiB
GiB
)
func stringifyRecordingProgress(s *bytes.Buffer, nBytes int) {
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, sdk *bngsdk.BeamNGSDK) {
// NOTE: write a string serialization function on the SDK itself
fmt.Fprint(s, "Outgauge {\n")
fmt.Fprintf(s, " Time: %d ms\n", sdk.Data.Time)
fmt.Fprintf(s, " Car: %s\n", sdk.Data.Car)
fmt.Fprintf(s, " Flags: %b\n", sdk.Data.Flags)
fmt.Fprintf(s, " Gear: %d\n", sdk.Data.Gear)
fmt.Fprintf(s, " Plid: %d\n", sdk.Data.Plid)
fmt.Fprintf(s, " Speed: %f m/s\n", sdk.Data.Speed)
fmt.Fprintf(s, " RPM: %f RPM\n", sdk.Data.RPM)
fmt.Fprintf(s, " Turbo: %f Bar\n", sdk.Data.Turbo)
fmt.Fprintf(s, " EngTemp: %f °C\n", sdk.Data.EngTemp)
fmt.Fprintf(s, " Fuel: %f\n", sdk.Data.Fuel)
fmt.Fprintf(s, " OilPressure: %f Bar\n", sdk.Data.OilPressure)
fmt.Fprintf(s, " OilTemp: %f °C\n", sdk.Data.OilTemp)
fmt.Fprintf(s, " DashLights: %b\n", sdk.Data.DashLights)
fmt.Fprintf(s, " ShowLights: %b\n", sdk.Data.ShowLights)
fmt.Fprintf(s, " Throttle: %f\n", sdk.Data.Throttle)
fmt.Fprintf(s, " Brakes: %f\n", sdk.Data.Brake)
fmt.Fprintf(s, " Clutch: %f\n", sdk.Data.Clutch)
fmt.Fprintf(s, " Display1: %s\n", sdk.Data.Display1)
fmt.Fprintf(s, " Display2: %s\n", sdk.Data.Display2)
fmt.Fprintf(s, " ID: %d\n", sdk.Data.ID)
fmt.Fprint(s, "}\n\n")
fmt.Fprint(s, "DashLights {\n")
fmt.Fprintf(s, " DL_SHIFT: %t\n", sdk.HasShiftLight())
fmt.Fprintf(s, " DL_FULLBEAM: %t\n", sdk.HasHighBeamLight())
fmt.Fprintf(s, " DL_HANDBRAKE: %t\n", sdk.HasHandbrakeLight())
fmt.Fprintf(s, " DL_PITSPEED: %t\n", sdk.HasPitspeed())
fmt.Fprintf(s, " DL_TC: %t\n", sdk.HasTractionControlLight())
fmt.Fprintf(s, " DL_SIGNAL_L: %t\n", sdk.HasLeftIndicatorLight())
fmt.Fprintf(s, " DL_SIGNAL_R: %t\n", sdk.HasRightIndicatorLight())
fmt.Fprintf(s, " DL_SIGNAL_ANY: %t\n", sdk.HasAnyIndicatorLight())
fmt.Fprintf(s, " DL_OILWARN: %t\n", sdk.HasOilLight())
fmt.Fprintf(s, " DL_BATTERY: %t\n", sdk.HasBatteryLight())
fmt.Fprintf(s, " DL_ABS: %t\n", sdk.HasABSLight())
fmt.Fprintf(s, " DL_SPARE: %t\n", sdk.Data.DashLights&bngsdk.DL_SPARE != 0)
fmt.Fprint(s, "}\n\n")
fmt.Fprint(s, "ShowLights {\n") // Fixed typo "ShowLigths"
fmt.Fprintf(s, " DL_SHIFT: %t\n", sdk.ShiftLight())
fmt.Fprintf(s, " DL_FULLBEAM: %t\n", sdk.HighBeam())
fmt.Fprintf(s, " DL_HANDBRAKE: %t\n", sdk.Handbrake())
fmt.Fprintf(s, " DL_PITSPEED: %t\n", sdk.Pitspeed())
fmt.Fprintf(s, " DL_TC: %t\n", sdk.TractionControl())
fmt.Fprintf(s, " DL_SIGNAL_L: %t\n", sdk.LeftIndicator())
fmt.Fprintf(s, " DL_SIGNAL_R: %t\n", sdk.RightIndicator())
fmt.Fprintf(s, " DL_SIGNAL_ANY: %t\n", sdk.AnyIndicator())
fmt.Fprintf(s, " DL_OILWARN: %t\n", sdk.OilLight())
fmt.Fprintf(s, " DL_BATTERY: %t\n", sdk.BatteryLight())
fmt.Fprintf(s, " DL_ABS: %t\n", sdk.ABS())
fmt.Fprintf(s, " DL_SPARE: %t\n", sdk.Data.ShowLights&bngsdk.DL_SPARE != 0)
fmt.Fprint(s, "}\n\n")
fmt.Fprint(s, "Flags {\n")
fmt.Fprintf(s, " OG_TURBO (Has Turbo): %t\n", sdk.HasTurbo())
fmt.Fprintf(s, " OG_KM (Is Metric): %t\n", sdk.PrefersKm())
fmt.Fprintf(s, " OG_BAR (Pressure): %t\n", sdk.PrefersBAR())
fmt.Fprint(s, "}")
}