backup_db experimental option|

Author: jvde-github

Application/WebViewer.cpp

@@ -165,6 +165,12 @@ bool WebViewer::Save()
 			return false;
 		if (!hist_day.Save(infile))
 			return false;
+		// Save ship database
+		if (backupDB)
+		{
+			if (!ships.Save(infile))
+				return false;
+		}
 		infile.close();
 	}
 	catch (const std::exception &e)
@@ -207,6 +213,12 @@ bool WebViewer::Load()
 			return false;
 		if (!hist_day.Load(infile))
 			return false;
+		// Load ship database if available
+		if (infile.peek() != EOF && backupDB)
+		{
+			if (!ships.Load(infile))
+				Warning() << "Server: Could not load ship database from backup";
+		}
 
 		infile.close();
 	}
@@ -685,7 +697,7 @@ void WebViewer::Request(TCP::ServerConnection &c, const std::string &response, b
 	{
 		std::stringstream ss(a);
 		std::string mmsi_str;
-		
+
 		if (std::getline(ss, mmsi_str))
 		{
 			try
@@ -881,6 +893,10 @@ Setting &WebViewer::Set(std::string option, std::string arg)
 		counter.setCutOff(cutoff);
 		counter_session.setCutOff(cutoff);
 	}
+	else if (option == "BACKUP_DB")
+	{
+		backupDB = Util::Parse::Switch(arg);
+	}
 	else if (option == "SHARE_LOC")
 	{
 		bool b = Util::Parse::Switch(arg);

Application/WebViewer.h

@@ -105,6 +105,7 @@ class WebViewer : public IO::HTTPServer, public Setting
 	bool supportPrometheus = false;
 	bool thread_running = false;
 	bool aboutPresent = false;
+	bool backupDB = false;
 
 	std::vector<char> binary;
 	std::vector<std::shared_ptr<MapTiles>> mapSources;

Tracking/DB.cpp

@@ -479,7 +479,7 @@ std::string DB::getSinglePathGeoJSON(int idx)
 		{
 			if (hasCoordinates)
 				geojson += ",";
-			
+
 			// GeoJSON uses [longitude, latitude] format (note the order!)
 			geojson += "[";
 			geojson += std::to_string(paths[ptr].lon);
@@ -491,7 +491,7 @@ std::string DB::getSinglePathGeoJSON(int idx)
 		t = paths[ptr].count;
 		ptr = paths[ptr].next;
 	}
-	
+
 	geojson += "]},\"properties\":{\"mmsi\":" + std::to_string(mmsi) + "}}";
 	return geojson;
 }
@@ -993,3 +993,121 @@ void DB::Receive(const JSON::JSON *data, int len, TAG &tag)
 
 	Send(data, len, tag);
 }
+
+bool DB::Save(std::ofstream &file)
+{
+	std::lock_guard<std::mutex> lock(mtx);
+
+	// Write magic number and version
+	int magic = _DB_MAGIC;
+	int version = _DB_VERSION;
+
+	if (!file.write((const char *)&magic, sizeof(int)))
+		return false;
+	if (!file.write((const char *)&version, sizeof(int)))
+		return false;
+
+	// Write ship count first
+	if (!file.write((const char *)&count, sizeof(int)))
+		return false;
+
+	// Find the position to start writing backwards by counting valid ships
+	int ptr = first;
+	int valid_ships_seen = 0;
+	while (ptr != -1 && valid_ships_seen < count)
+	{
+		if (ships[ptr].mmsi != 0)
+			valid_ships_seen++;
+		if (valid_ships_seen < count)
+			ptr = ships[ptr].next;
+	}
+
+	// Now write ships by traversing backwards from that position
+	int ships_written = 0;
+	while (ptr != -1 && ships_written < count)
+	{
+		if (ships[ptr].mmsi != 0)
+		{
+			if (!file.write((const char *)&ships[ptr], sizeof(Ship)))
+				return false;
+			ships_written++;
+		}
+		ptr = ships[ptr].prev;
+	}
+
+	Info() << "DB: Saved " << ships_written << " ships to backup";
+	return true;
+}
+
+bool DB::Load(std::ifstream &file)
+{
+	std::lock_guard<std::mutex> lock(mtx);
+
+	std::cerr << "Loading ships from backup file." << std::endl;
+
+	int magic = 0, version = 0;
+
+	// Read and verify magic number and version
+	if (!file.read((char *)&magic, sizeof(int)))
+		return false;
+	if (!file.read((char *)&version, sizeof(int)))
+		return false;
+
+	if (magic != _DB_MAGIC || version != _DB_VERSION)
+	{
+		Warning() << "DB: Invalid backup file format. Magic: " << std::hex << magic
+				  << ", Version: " << version;
+		return false;
+	}
+
+	// Read number of active ships
+	int active_ships = 0;
+	if (!file.read((char *)&active_ships, sizeof(int)))
+		return false;
+
+	if (active_ships < 0 || active_ships > Nships)
+	{
+		Warning() << "DB: Invalid ship count in backup file: " << active_ships;
+		return false;
+	}
+
+	// Load ships and validate chronological order (oldest first, then newer)
+	std::time_t previous_signal = 0;
+	for (int i = 0; i < active_ships; i++)
+	{
+		Ship temp_ship;
+		if (!file.read((char *)&temp_ship, sizeof(Ship)))
+		{
+			std::cout << "DB: Failed to read ship " << i << " from backup file." << std::endl;
+			return false;
+		}
+
+		// Validate chronological order - ships should be oldest first
+		if (i > 0 && temp_ship.last_signal < previous_signal)
+		{
+			Warning() << "DB: Ships not in chronological order in backup file. "
+					  << "Ship " << i << " (MMSI " << temp_ship.mmsi << ") "
+					  << "has timestamp " << temp_ship.last_signal
+					  << " which is older than previous ship timestamp " << previous_signal;
+			return false;
+		}
+		previous_signal = temp_ship.last_signal;
+
+		// Find or create ship entry using existing mechanisms
+		int ptr = findShip(temp_ship.mmsi);
+		if (ptr == -1)
+			ptr = createShip();
+
+		moveShipToFront(ptr);
+
+		// Copy ship data while preserving linked list pointers
+		int next_ptr = ships[ptr].next;
+		int prev_ptr = ships[ptr].prev;
+		ships[ptr] = temp_ship;
+		ships[ptr].next = next_ptr;
+		ships[ptr].prev = prev_ptr;
+	}
+
+	Info() << "DB: Restored " << count << " ships from backup";
+	return true;
+}

Tracking/DB.h

@@ -162,4 +162,12 @@ class DB : public StreamIn<JSON::JSON>,
 	void setFilterOption(std::string &opt, std::string &arg) { filter.SetOption(opt, arg); }
 
 	std::string getBinaryMessagesJSON() const;
+
+	// Persistence functions for ship database
+	bool Save(std::ofstream& file);
+	bool Load(std::ifstream& file);
+
+private:
+	static const int _DB_MAGIC = 0x41495344; // "AISD" in hex
+	static const int _DB_VERSION = 1;
 };

Tracking/Ships.h

@@ -1,18 +1,18 @@
 /*
-	Copyright(c) 2021-2025 jvde.github@gmail.com
+    Copyright(c) 2021-2025 jvde.github@gmail.com
 
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
 
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
 
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 #pragma once
@@ -34,7 +34,8 @@ const int BASESTATION_MASK = (1 << 4) | (1 << 16) | (1 << 17) | (1 << 20) | (1 <
 const int SAR_MASK = 1 << 9;
 const int ATON_MASK = 1 << 21;
 
-struct Ship {
+struct Ship
+{
     int prev, next;
     uint32_t mmsi;
     int count, msg_type, shipclass, mmsi_type, shiptype, heading, status, path_ptr;
@@ -52,9 +53,9 @@ struct Ship {
     int getShipTypeClassEri();
     int getShipTypeClass();
     void setType();
-    void Serialize(std::vector<char>& v) const;
-    bool getKML(std::string&) const;
-    bool getGeoJSON(std::string&) const;
+    void Serialize(std::vector<char> &v) const;
+    bool getKML(std::string &) const;
+    bool getGeoJSON(std::string &) const;
 
     // Setters for PackedInt fields
     void setValidated(int val) { flags.set(0, 2, val); }