487 lines
10 KiB
Go
487 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"time"
|
|
)
|
|
|
|
// NewLogRingBuffer creates a new ring buffer with the specified capacity
|
|
func NewLogRingBuffer(capacity int) *LogRingBuffer {
|
|
return &LogRingBuffer{
|
|
entries: make([]LogEntry, capacity),
|
|
size: capacity,
|
|
position: 0,
|
|
count: 0,
|
|
}
|
|
}
|
|
|
|
// Add adds a log entry to the ring buffer
|
|
func (rb *LogRingBuffer) Add(entry LogEntry) {
|
|
rb.mutex.Lock()
|
|
defer rb.mutex.Unlock()
|
|
|
|
rb.entries[rb.position] = entry
|
|
rb.position = (rb.position + 1) % rb.size
|
|
if rb.count < rb.size {
|
|
rb.count++
|
|
}
|
|
}
|
|
|
|
// GetAll returns all entries in the buffer from newest to oldest
|
|
func (rb *LogRingBuffer) GetAll() []LogEntry {
|
|
rb.mutex.Lock()
|
|
defer rb.mutex.Unlock()
|
|
|
|
result := make([]LogEntry, rb.count)
|
|
|
|
if rb.count == 0 {
|
|
return result
|
|
}
|
|
|
|
// Copy entries in reverse chronological order (newest first)
|
|
pos := rb.position - 1
|
|
if pos < 0 {
|
|
pos = rb.size - 1
|
|
}
|
|
|
|
for i := 0; i < rb.count; i++ {
|
|
result[i] = rb.entries[pos]
|
|
pos--
|
|
if pos < 0 {
|
|
pos = rb.size - 1
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func setupDatabase() error {
|
|
_, err := db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS articles (
|
|
link TEXT PRIMARY KEY,
|
|
title TEXT NOT NULL,
|
|
description TEXT,
|
|
published TIMESTAMP NOT NULL,
|
|
originalDate TIMESTAMP,
|
|
source TEXT NOT NULL,
|
|
firstseen TIMESTAMP NOT NULL,
|
|
seen TIMESTAMP,
|
|
summary TEXT,
|
|
importance INTEGER,
|
|
id TEXT,
|
|
broadcastTime TIMESTAMP
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Check if columns exist
|
|
rows, err := db.Query(`PRAGMA table_info(articles)`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
|
|
hasIDColumn := false
|
|
hasBroadcastTimeColumn := false
|
|
hasOriginalDateColumn := false
|
|
|
|
for rows.Next() {
|
|
var cid, notnull, pk int
|
|
var name, type_name string
|
|
var dflt_value interface{}
|
|
if err := rows.Scan(&cid, &name, &type_name, ¬null, &dflt_value, &pk); err != nil {
|
|
return err
|
|
}
|
|
if name == "id" {
|
|
hasIDColumn = true
|
|
}
|
|
if name == "broadcastTime" {
|
|
hasBroadcastTimeColumn = true
|
|
}
|
|
if name == "originalDate" {
|
|
hasOriginalDateColumn = true
|
|
}
|
|
}
|
|
|
|
// Add missing columns if needed
|
|
if !hasIDColumn {
|
|
_, err = db.Exec(`ALTER TABLE articles ADD COLUMN id TEXT`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if !hasBroadcastTimeColumn {
|
|
_, err = db.Exec(`ALTER TABLE articles ADD COLUMN broadcastTime TIMESTAMP`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if !hasOriginalDateColumn {
|
|
_, err = db.Exec(`ALTER TABLE articles ADD COLUMN originalDate TIMESTAMP`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
logInfo("db", "Added originalDate column to articles table", nil)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Generate a deterministic ID from a URL
|
|
func generateID(url string) string {
|
|
hash := sha256.Sum256([]byte(url))
|
|
return hex.EncodeToString(hash[:])[:26] // Return first 26 chars of the hash
|
|
}
|
|
|
|
func saveArticle(article Article) error {
|
|
_, err := db.Exec(`
|
|
INSERT OR IGNORE INTO articles
|
|
(link, title, description, published, originalDate, source, firstseen, seen, summary, importance, id, broadcastTime)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
article.Link, article.Title, article.Description, article.Published, article.OriginalDate,
|
|
article.Source, article.FirstSeen, article.Seen, article.Summary, article.Importance, article.ID,
|
|
article.BroadcastTime)
|
|
|
|
if err != nil {
|
|
logEvent("db_insert_error", map[string]interface{}{
|
|
"article": article.Link,
|
|
"id": article.ID,
|
|
"error": err.Error(),
|
|
})
|
|
}
|
|
return err
|
|
}
|
|
|
|
func updateArticle(article Article) error {
|
|
_, err := db.Exec(`
|
|
UPDATE articles SET
|
|
title = ?,
|
|
description = ?,
|
|
published = ?,
|
|
originalDate = ?,
|
|
source = ?,
|
|
firstseen = ?,
|
|
seen = ?,
|
|
summary = ?,
|
|
importance = ?,
|
|
id = ?,
|
|
broadcastTime = ?
|
|
WHERE link = ?
|
|
`,
|
|
article.Title, article.Description, article.Published, article.OriginalDate, article.Source,
|
|
article.FirstSeen, article.Seen, article.Summary, article.Importance, article.ID,
|
|
article.BroadcastTime, article.Link)
|
|
|
|
if err != nil {
|
|
logEvent("db_update_error", map[string]interface{}{
|
|
"article": article.Link,
|
|
"id": article.ID,
|
|
"error": err.Error(),
|
|
})
|
|
}
|
|
return err
|
|
}
|
|
|
|
func loadArticles() map[string]Article {
|
|
articles := make(map[string]Article)
|
|
|
|
rows, err := db.Query(`
|
|
SELECT link, title, description, published, originalDate, source, firstseen, seen, summary, importance, id, broadcastTime
|
|
FROM articles
|
|
`)
|
|
if err != nil {
|
|
logEvent("db_query_error", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return articles
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var a Article
|
|
var seen sql.NullTime
|
|
var broadcastTime sql.NullTime
|
|
var originalDate sql.NullTime
|
|
|
|
err := rows.Scan(
|
|
&a.Link, &a.Title, &a.Description, &a.Published, &originalDate, &a.Source,
|
|
&a.FirstSeen, &seen, &a.Summary, &a.Importance, &a.ID, &broadcastTime,
|
|
)
|
|
|
|
if err != nil {
|
|
logEvent("db_scan_error", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
continue
|
|
}
|
|
|
|
if seen.Valid {
|
|
a.Seen = seen.Time
|
|
}
|
|
|
|
if broadcastTime.Valid {
|
|
a.BroadcastTime = broadcastTime.Time
|
|
}
|
|
|
|
if originalDate.Valid {
|
|
a.OriginalDate = originalDate.Time
|
|
}
|
|
|
|
articles[a.Link] = a
|
|
}
|
|
|
|
return articles
|
|
}
|
|
|
|
// getBroadcastHistory gets the most recent broadcast articles
|
|
func getBroadcastHistory(limit int) ([]Article, error) {
|
|
rows, err := db.Query(`
|
|
SELECT link, title, description, published, originalDate, source, firstseen, seen, summary, importance, id, broadcastTime
|
|
FROM articles
|
|
WHERE broadcastTime IS NOT NULL
|
|
AND broadcastTime > 1
|
|
AND broadcastTime != 0
|
|
AND datetime(broadcastTime) != '1970-01-01 00:00:00'
|
|
AND datetime(broadcastTime) != '0001-01-01 00:00:00'
|
|
AND strftime('%Y', broadcastTime) > '2000' -- Ensure year is at least 2000
|
|
ORDER BY broadcastTime DESC
|
|
LIMIT ?
|
|
`, limit)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var articles []Article
|
|
for rows.Next() {
|
|
var a Article
|
|
var seen sql.NullTime
|
|
var broadcastTime sql.NullTime
|
|
var originalDate sql.NullTime
|
|
|
|
err := rows.Scan(
|
|
&a.Link, &a.Title, &a.Description, &a.Published, &originalDate, &a.Source,
|
|
&a.FirstSeen, &seen, &a.Summary, &a.Importance, &a.ID, &broadcastTime,
|
|
)
|
|
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if seen.Valid {
|
|
a.Seen = seen.Time
|
|
}
|
|
|
|
if broadcastTime.Valid {
|
|
a.BroadcastTime = broadcastTime.Time
|
|
}
|
|
|
|
if originalDate.Valid {
|
|
a.OriginalDate = originalDate.Time
|
|
}
|
|
|
|
articles = append(articles, a)
|
|
}
|
|
|
|
return articles, nil
|
|
}
|
|
|
|
// getNextUpArticles gets the top 25 articles eligible for broadcast sorted by importance
|
|
func getNextUpArticles() ([]Article, error) {
|
|
now := time.Now()
|
|
cutoff := now.Add(-ARTICLE_FRESHNESS_WINDOW) // Time window for considering articles fresh
|
|
|
|
rows, err := db.Query(`
|
|
SELECT link, title, description, published, originalDate, source, firstseen, seen, summary, importance, id, broadcastTime
|
|
FROM articles
|
|
WHERE broadcastTime IS NULL
|
|
AND summary IS NOT NULL
|
|
AND importance > 0
|
|
AND firstseen > ?
|
|
ORDER BY importance DESC
|
|
LIMIT 25
|
|
`, cutoff)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var articles []Article
|
|
for rows.Next() {
|
|
var a Article
|
|
var seen sql.NullTime
|
|
var broadcastTime sql.NullTime
|
|
var originalDate sql.NullTime
|
|
|
|
err := rows.Scan(
|
|
&a.Link, &a.Title, &a.Description, &a.Published, &originalDate, &a.Source,
|
|
&a.FirstSeen, &seen, &a.Summary, &a.Importance, &a.ID, &broadcastTime,
|
|
)
|
|
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if seen.Valid {
|
|
a.Seen = seen.Time
|
|
}
|
|
|
|
if broadcastTime.Valid {
|
|
a.BroadcastTime = broadcastTime.Time
|
|
}
|
|
|
|
if originalDate.Valid {
|
|
a.OriginalDate = originalDate.Time
|
|
}
|
|
|
|
articles = append(articles, a)
|
|
}
|
|
|
|
return articles, nil
|
|
}
|
|
|
|
// getRecentBroadcasts retrieves the n most recently broadcast articles
|
|
func getRecentBroadcasts(n int) []Article {
|
|
rows, err := db.Query(`
|
|
SELECT link, title, description, published, originalDate, source, firstseen, seen, summary, importance, id, broadcastTime
|
|
FROM articles
|
|
WHERE broadcastTime IS NOT NULL AND broadcastTime > 1
|
|
ORDER BY broadcastTime DESC
|
|
LIMIT ?
|
|
`, n)
|
|
|
|
if err != nil {
|
|
logInfo("db", "Error retrieving recent broadcasts", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return []Article{}
|
|
}
|
|
defer rows.Close()
|
|
|
|
var broadcasts []Article
|
|
for rows.Next() {
|
|
var a Article
|
|
var seen sql.NullTime
|
|
var broadcastTime sql.NullTime
|
|
var originalDate sql.NullTime
|
|
|
|
err := rows.Scan(
|
|
&a.Link, &a.Title, &a.Description, &a.Published, &originalDate, &a.Source,
|
|
&a.FirstSeen, &seen, &a.Summary, &a.Importance, &a.ID, &broadcastTime,
|
|
)
|
|
|
|
if err != nil {
|
|
logInfo("db", "Error scanning broadcast article", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
continue
|
|
}
|
|
|
|
if seen.Valid {
|
|
a.Seen = seen.Time
|
|
}
|
|
|
|
if broadcastTime.Valid {
|
|
a.BroadcastTime = broadcastTime.Time
|
|
}
|
|
|
|
if originalDate.Valid {
|
|
a.OriginalDate = originalDate.Time
|
|
}
|
|
|
|
broadcasts = append(broadcasts, a)
|
|
}
|
|
|
|
return broadcasts
|
|
}
|
|
|
|
func setupLogging() {
|
|
var err error
|
|
logFile, err = os.Create(logPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "could not create log file: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func flushLog() {
|
|
logMutex.Lock()
|
|
defer logMutex.Unlock()
|
|
|
|
if logFile == nil {
|
|
return
|
|
}
|
|
|
|
enc := json.NewEncoder(logFile)
|
|
enc.SetIndent("", " ")
|
|
_ = enc.Encode(logData)
|
|
logFile.Close()
|
|
}
|
|
|
|
func logEvent(event string, details map[string]interface{}) {
|
|
logMutex.Lock()
|
|
defer logMutex.Unlock()
|
|
|
|
details["timestamp"] = time.Now()
|
|
details["event"] = event
|
|
|
|
entry := LogEntry{
|
|
Timestamp: time.Now(),
|
|
Event: event,
|
|
Details: details,
|
|
}
|
|
|
|
// Add to both the permanent log data and the ring buffer
|
|
logData = append(logData, entry)
|
|
logBuffer.Add(entry)
|
|
}
|
|
|
|
// logInfo logs a structured message to both console and log file
|
|
func logInfo(component, message string, data map[string]interface{}) {
|
|
// Create a copy of the data map to avoid modifying the original
|
|
logData := make(map[string]interface{})
|
|
for k, v := range data {
|
|
logData[k] = v
|
|
}
|
|
|
|
// Add component and message to the log data
|
|
logData["component"] = component
|
|
logData["message"] = message
|
|
|
|
// Format console output: timestamp component: message key1=val1 key2=val2
|
|
timestamp := time.Now().Format("15:04:05.000")
|
|
console := fmt.Sprintf("[%s] [%s] %s", timestamp, component, message)
|
|
|
|
// Add key-value pairs to console output
|
|
keys := make([]string, 0, len(data))
|
|
for k := range data {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys) // Sort keys for consistent output
|
|
|
|
for _, k := range keys {
|
|
v := data[k]
|
|
console += fmt.Sprintf(" %s=%v", k, v)
|
|
}
|
|
|
|
// Print to console
|
|
fmt.Fprintln(os.Stderr, console)
|
|
|
|
// Log to structured log file
|
|
logEvent("info", logData)
|
|
}
|