325 lines
11 KiB
HTML
325 lines
11 KiB
HTML
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
|
|
<title>drone-black-box: Go Coverage Report</title>
|
|
<style>
|
|
body {
|
|
background: black;
|
|
color: rgb(80, 80, 80);
|
|
}
|
|
body, pre, #legend span {
|
|
font-family: Menlo, monospace;
|
|
font-weight: bold;
|
|
}
|
|
#topbar {
|
|
background: black;
|
|
position: fixed;
|
|
top: 0; left: 0; right: 0;
|
|
height: 42px;
|
|
border-bottom: 1px solid rgb(80, 80, 80);
|
|
}
|
|
#content {
|
|
margin-top: 50px;
|
|
}
|
|
#nav, #legend {
|
|
float: left;
|
|
margin-left: 10px;
|
|
}
|
|
#legend {
|
|
margin-top: 12px;
|
|
}
|
|
#nav {
|
|
margin-top: 10px;
|
|
}
|
|
#legend span {
|
|
margin: 0 5px;
|
|
}
|
|
.cov0 { color: rgb(192, 0, 0) }
|
|
.cov1 { color: rgb(128, 128, 128) }
|
|
.cov2 { color: rgb(116, 140, 131) }
|
|
.cov3 { color: rgb(104, 152, 134) }
|
|
.cov4 { color: rgb(92, 164, 137) }
|
|
.cov5 { color: rgb(80, 176, 140) }
|
|
.cov6 { color: rgb(68, 188, 143) }
|
|
.cov7 { color: rgb(56, 200, 146) }
|
|
.cov8 { color: rgb(44, 212, 149) }
|
|
.cov9 { color: rgb(32, 224, 152) }
|
|
.cov10 { color: rgb(20, 236, 155) }
|
|
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div id="topbar">
|
|
<div id="nav">
|
|
<select id="files">
|
|
|
|
<option value="file0">drone-black-box/main.go (51.6%)</option>
|
|
|
|
</select>
|
|
</div>
|
|
<div id="legend">
|
|
<span>not tracked</span>
|
|
|
|
<span class="cov0">not covered</span>
|
|
<span class="cov8">covered</span>
|
|
|
|
</div>
|
|
</div>
|
|
<div id="content">
|
|
|
|
<pre class="file" id="file0" style="display: none">package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
// DroneEvent defines the DroneEvent struct as JSON
|
|
type DroneEvent struct {
|
|
DroneID string `json:"droneId"`
|
|
Latitude float64 `json:"latitude"`
|
|
Longitude float64 `json:"longitude"`
|
|
Timestamp string `json:"timestamp"`
|
|
}
|
|
|
|
type Server struct {
|
|
db *sql.DB
|
|
}
|
|
|
|
var allowedOrigins = map[string]struct{}{
|
|
"http://localhost:4173": {},
|
|
"http://127.0.0.1:4173": {},
|
|
"http://localhost:5173": {},
|
|
"http://127.0.0.1:5173": {},
|
|
}
|
|
|
|
// corsMiddleware adds the headers needed for cross-origin requests from the frontend.
|
|
func corsMiddleware(next http.Handler) http.Handler <span class="cov8" title="1">{
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) </span><span class="cov8" title="1">{
|
|
origin := r.Header.Get("Origin")
|
|
if _, ok := allowedOrigins[origin]; ok </span><span class="cov8" title="1">{
|
|
w.Header().Set("Access-Control-Allow-Origin", origin)
|
|
w.Header().Set("Vary", "Origin")
|
|
}</span>
|
|
|
|
<span class="cov8" title="1">w.Header().Set("Access-Control-Allow-Methods", "GET,POST,OPTIONS")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
w.Header().Set("Access-Control-Max-Age", "86400")
|
|
|
|
// Handle preflight without hitting the underlying handlers.
|
|
if r.Method == http.MethodOptions </span><span class="cov8" title="1">{
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return
|
|
}</span>
|
|
|
|
<span class="cov8" title="1">next.ServeHTTP(w, r)</span>
|
|
})
|
|
}
|
|
|
|
// Ingest handler
|
|
func (s *Server) ingestHandler(w http.ResponseWriter, r *http.Request) <span class="cov8" title="1">{
|
|
var event DroneEvent
|
|
if err := json.NewDecoder(r.Body).Decode(&event); err != nil </span><span class="cov8" title="1">{
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
slog.Error("Failed to decode request body", "error", err)
|
|
return
|
|
}</span>
|
|
|
|
<span class="cov8" title="1">slog.Info("Ingesting event", "drone_id", event.DroneID, "timestamp", event.Timestamp)
|
|
|
|
_, err := s.db.Exec("INSERT INTO drone_events (drone_id, latitude, longitude, timestamp) VALUES (?, ?, ?, ?)",
|
|
event.DroneID, event.Latitude, event.Longitude, event.Timestamp)
|
|
if err != nil </span><span class="cov8" title="1">{
|
|
slog.Error("Failed to insert event", "error", err)
|
|
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
|
|
return
|
|
}</span>
|
|
|
|
<span class="cov8" title="1">w.WriteHeader(http.StatusCreated)</span>
|
|
}
|
|
|
|
// Snapshot handler
|
|
func (s *Server) snapshotHandler(w http.ResponseWriter, r *http.Request) <span class="cov8" title="1">{
|
|
timeParam := r.URL.Query().Get("time")
|
|
if timeParam == "" </span><span class="cov8" title="1">{
|
|
http.Error(w, "Missing 'time' query parameter", http.StatusBadRequest)
|
|
return
|
|
}</span>
|
|
|
|
<span class="cov8" title="1">query := `
|
|
SELECT drone_id, latitude, longitude, timestamp
|
|
FROM drone_events t1
|
|
WHERE timestamp = (
|
|
SELECT MAX(timestamp)
|
|
FROM drone_events t2
|
|
WHERE t2.drone_id = t1.drone_id AND t2.timestamp <= ?
|
|
)
|
|
`
|
|
|
|
rows, err := s.db.Query(query, timeParam)
|
|
if err != nil </span><span class="cov8" title="1">{
|
|
slog.Error("Failed to query snapshot", "error", err)
|
|
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
|
|
return
|
|
}</span>
|
|
<span class="cov8" title="1">defer rows.Close()
|
|
|
|
results := []DroneEvent{}
|
|
for rows.Next() </span><span class="cov8" title="1">{
|
|
var event DroneEvent
|
|
if err := rows.Scan(&event.DroneID, &event.Latitude, &event.Longitude, &event.Timestamp); err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Failed to scan row", "error", err)
|
|
continue</span>
|
|
}
|
|
<span class="cov8" title="1">results = append(results, event)</span>
|
|
}
|
|
|
|
<span class="cov8" title="1">slog.Info("Snapshot retrieved", "time", timeParam, "count", len(results))
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(results); err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Failed to encode response", "error", err)
|
|
}</span>
|
|
}
|
|
|
|
// Health check handler
|
|
func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) <span class="cov8" title="1">{
|
|
if err := s.db.Ping(); err != nil </span><span class="cov8" title="1">{
|
|
slog.Error("Health check failed", "error", err)
|
|
http.Error(w, "Database unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}</span>
|
|
<span class="cov8" title="1">w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("OK"))</span>
|
|
}
|
|
|
|
func main() <span class="cov0" title="0">{
|
|
// Setup structured logging
|
|
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
|
slog.SetDefault(logger)
|
|
|
|
port := os.Getenv("BLACKBOX_PORT")
|
|
if port == "" </span><span class="cov0" title="0">{
|
|
port = "3000"
|
|
}</span>
|
|
|
|
// Open database
|
|
<span class="cov0" title="0">db, err := sql.Open("sqlite", "./drone_black_box.db")
|
|
if err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Failed to open database", "error", err)
|
|
os.Exit(1)
|
|
}</span>
|
|
<span class="cov0" title="0">defer db.Close()
|
|
|
|
// Performance optimizations for SQLite
|
|
// WAL mode allows simultaneous readers and one writer
|
|
if _, err := db.Exec("PRAGMA journal_mode=WAL;"); err != nil </span><span class="cov0" title="0">{
|
|
slog.Warn("Failed to enable WAL mode", "error", err)
|
|
}</span>
|
|
// Busy timeout prevents "database is locked" errors during high concurrency
|
|
<span class="cov0" title="0">if _, err := db.Exec("PRAGMA busy_timeout=5000;"); err != nil </span><span class="cov0" title="0">{
|
|
slog.Warn("Failed to set busy timeout", "error", err)
|
|
}</span>
|
|
|
|
<span class="cov0" title="0">db.SetMaxOpenConns(1)
|
|
|
|
// Create table
|
|
createTableSQL := `CREATE TABLE IF NOT EXISTS drone_events (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
drone_id TEXT NOT NULL,
|
|
latitude REAL NOT NULL,
|
|
longitude REAL NOT NULL,
|
|
timestamp TEXT NOT NULL
|
|
);`
|
|
if _, err := db.Exec(createTableSQL); err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Failed to create table", "error", err)
|
|
os.Exit(1)
|
|
}</span>
|
|
|
|
// Create index for performance
|
|
// Indexing drone_id and timestamp significantly speeds up the snapshot query
|
|
<span class="cov0" title="0">createIndexSQL := `CREATE INDEX IF NOT EXISTS idx_drone_timestamp ON drone_events(drone_id, timestamp);`
|
|
if _, err := db.Exec(createIndexSQL); err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Failed to create index", "error", err)
|
|
os.Exit(1)
|
|
}</span>
|
|
|
|
<span class="cov0" title="0">server := &Server{db: db}
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("POST /ingest", server.ingestHandler)
|
|
mux.HandleFunc("GET /snapshot", server.snapshotHandler)
|
|
mux.HandleFunc("GET /health", server.healthHandler)
|
|
|
|
httpServer := &http.Server{
|
|
Addr: ":" + port,
|
|
Handler: corsMiddleware(mux),
|
|
}
|
|
|
|
// Graceful shutdown
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
|
|
|
|
go func() </span><span class="cov0" title="0">{
|
|
slog.Info("Black Box Service is running", "port", port)
|
|
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed </span><span class="cov0" title="0">{
|
|
slog.Error("HTTP server error", "error", err)
|
|
os.Exit(1)
|
|
}</span>
|
|
}()
|
|
|
|
<span class="cov0" title="0"><-stop
|
|
slog.Info("Shutting down server...")
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
if err := httpServer.Shutdown(ctx); err != nil </span><span class="cov0" title="0">{
|
|
slog.Error("Server forced to shutdown", "error", err)
|
|
}</span>
|
|
|
|
<span class="cov0" title="0">slog.Info("Server exited properly")</span>
|
|
}
|
|
</pre>
|
|
|
|
</div>
|
|
</body>
|
|
<script>
|
|
(function() {
|
|
var files = document.getElementById('files');
|
|
var visible;
|
|
files.addEventListener('change', onChange, false);
|
|
function select(part) {
|
|
if (visible)
|
|
visible.style.display = 'none';
|
|
visible = document.getElementById(part);
|
|
if (!visible)
|
|
return;
|
|
files.value = part;
|
|
visible.style.display = 'block';
|
|
location.hash = part;
|
|
}
|
|
function onChange() {
|
|
select(files.value);
|
|
window.scrollTo(0, 0);
|
|
}
|
|
if (location.hash != "") {
|
|
select(location.hash.substr(1));
|
|
}
|
|
if (!visible) {
|
|
select("file0");
|
|
}
|
|
})();
|
|
</script>
|
|
</html>
|