read and check for job already done from disk

internal/loggers/template_store.go

@@ -26,6 +26,7 @@ const (
 	DeviceSettingsFile = "/opt/autopi/device-settings.json"
 	VehicleInfoFile    = "/opt/autopi/vehicle-info.json"
 	DBCFile            = "/opt/autopi/dbc-settings.dbc"
+	CANDumpInfoFile    = "/opt/autopi/can-dump-info.json"
 )
 
 //go:generate mockgen -source template_store.go -destination mocks/template_store_mock.go
@@ -48,6 +49,10 @@ type SettingsStore interface {
 	ReadVehicleInfo() (*models.VehicleInfo, error)
 	WriteVehicleInfo(settings models.VehicleInfo) error
 	DeleteAllSettings() error
+
+	ReadCANDumpInfo() (*models.CANDumpInfo, error)
+	// WriteCANDumpInfo sets current date on disk
+	WriteCANDumpInfo() error
 }
 
 // settingsStore wraps reading and writing different configurations locally
@@ -64,6 +69,7 @@ func (ts *settingsStore) DeleteAllSettings() error {
 	errs = append(errs, ts.deleteConfig(VehicleInfoFile))
 	errs = append(errs, ts.deleteConfig(TemplateURLsFile))
 	errs = append(errs, ts.deleteConfig(DBCFile))
+	errs = append(errs, ts.deleteConfig(CANDumpInfoFile))
 
 	// Combine errors and print the result
 	if combinedErr := combineErrors(errs); combinedErr != nil {
@@ -235,6 +241,33 @@ func (ts *settingsStore) WriteVehicleInfo(settings models.VehicleInfo) error {
 	return nil
 }
 
+func (ts *settingsStore) ReadCANDumpInfo() (*models.CANDumpInfo, error) {
+	data, err := ts.readConfig(CANDumpInfoFile)
+	if err != nil {
+		return nil, fmt.Errorf("error reading file: %s", err)
+	}
+	cdi := &models.CANDumpInfo{}
+
+	err = json.Unmarshal(data, cdi)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshall vehicleInfo: %s", err)
+	}
+
+	return cdi, nil
+}
+
+// WriteCANDumpInfo just sets the date to now
+func (ts *settingsStore) WriteCANDumpInfo() error {
+	d := models.CANDumpInfo{DateExecuted: time.Now()}
+
+	err := ts.writeConfig(CANDumpInfoFile, d)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (ts *settingsStore) readConfig(filePath string) ([]byte, error) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()

internal/models/network.go

@@ -3,6 +3,7 @@ package models
 import (
 	"github.com/DIMO-Network/edge-network/internal/api"
 	"github.com/DIMO-Network/shared"
+	"time"
 )
 
 type CanDumpData struct {
@@ -101,6 +102,10 @@ type VehicleInfo struct {
 	VehicleDefinition VehicleDefinition `json:"definition"`
 }
 
+type CANDumpInfo struct {
+	DateExecuted time.Time `json:"dateExecuted"`
+}
+
 type VehicleDefinition struct {
 	Make  string `json:"make"`
 	Model string `json:"model"`

internal/signal_frame_dump_q.go

@@ -3,6 +3,7 @@ package internal
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/DIMO-Network/edge-network/internal/loggers"
 	"sync"
 	"time"
 
@@ -21,13 +22,24 @@ type SignalFrameDumpQueue struct {
 	sync.RWMutex
 	logger     zerolog.Logger
 	dataSender network.DataSender
+	lss        loggers.SettingsStore
 }
 
-func NewSignalFrameDumpQueue(logger zerolog.Logger, sender network.DataSender) *SignalFrameDumpQueue {
-	// todo set signal dump queue `jobDone` to true if we have something on disk
-	// leverage the config service to read something from disk and check
+func NewSignalFrameDumpQueue(logger zerolog.Logger, sender network.DataSender, lss loggers.SettingsStore) *SignalFrameDumpQueue {
+	// check if jobDone should just be marked to true
+	cdi, _ := lss.ReadCANDumpInfo()
+
 	return &SignalFrameDumpQueue{signalFrames: make(map[string][]models.SignalCanFrameDump), logger: logger,
-		dataSender: sender}
+		dataSender: sender, lss: lss, jobDone: determineJobDone(cdi)}
+}
+
+func determineJobDone(cdi *models.CANDumpInfo) bool {
+	jd := false
+	// 2024-10-01 ... now is 2024-10-15 -> false
+	if cdi != nil && cdi.DateExecuted.After(time.Now().Add(-31*24*time.Hour)) {
+		jd = true
+	}
+	return jd
 }
 
 func (scf *SignalFrameDumpQueue) Enqueue(signal models.SignalCanFrameDump) {

internal/signal_frame_dump_q_test.go

@@ -0,0 +1,47 @@
+package internal
+
+import (
+	"testing"
+	"time"
+
+	"github.com/DIMO-Network/edge-network/internal/models"
+)
+
+func TestDetermineJobDone(t *testing.T) {
+	now := time.Now()
+
+	testCases := []struct {
+		desc  string
+		input *models.CANDumpInfo
+		want  bool
+	}{
+		{
+			desc:  "nil CANDumpInfo",
+			input: nil,
+			want:  false,
+		},
+		{
+			desc:  "DateExecuted is older than 30 days",
+			input: &models.CANDumpInfo{DateExecuted: now.Add(-31 * 24 * time.Hour)},
+			want:  false,
+		},
+		{
+			desc:  "DateExecuted is equal to 30 days",
+			input: &models.CANDumpInfo{DateExecuted: now.Add(-30 * 24 * time.Hour)},
+			want:  true,
+		},
+		{
+			desc:  "DateExecuted is less than 30 days",
+			input: &models.CANDumpInfo{DateExecuted: now.Add(-29 * 24 * time.Hour)},
+			want:  true,
+		},
+	}
+
+	for _, tC := range testCases {
+		t.Run(tC.desc, func(t *testing.T) {
+			if got := determineJobDone(tC.input); got != tC.want {
+				t.Errorf("determineJobDone() = %v, want %v for input %v", got, tC.want, tC.input)
+			}
+		})
+	}
+}

internal/worker_runner.go

@@ -58,7 +58,7 @@ func NewWorkerRunner(addr *common.Address, loggerSettingsSvc loggers.SettingsSto
 	signalsQueue := &SignalsQueue{lastTimeChecked: make(map[string]time.Time), failureCount: make(map[string]int), signals: make(map[string][]models.SignalData)}
 	// Interval for sending status payload to cloud. Status payload contains obd signals and non-obd signals.
 	interval := 20 * time.Second
-	sdfq := NewSignalFrameDumpQueue(logger, dataSender)
+	sdfq := NewSignalFrameDumpQueue(logger, dataSender, loggerSettingsSvc)
 	return &workerRunner{ethAddr: addr, loggerSettingsSvc: loggerSettingsSvc,
 		dataSender: dataSender, logger: logger, fingerprintRunner: fpRunner, pids: pids, deviceSettings: settings,
 		signalsQueue: signalsQueue, sendPayloadInterval: interval, device: device, vehicleInfo: vehicleInfo,