122 lines
2.5 KiB
Go
122 lines
2.5 KiB
Go
// 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"
|
|
|
|
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,
|
|
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", 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 / 240)
|
|
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!
|
|
}
|
|
}
|
|
}
|
|
}
|