96 lines
3.4 KiB
Go
96 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// ============================================================================
|
|
// 🚀 GO 10: CHANNELS & DATENFLUSS (STREAMING PIPELINES)
|
|
// ============================================================================
|
|
|
|
// 🎯 TODO 1: Definiere das Struct 'LogRecord'
|
|
// Felder:
|
|
// - ID int (Eindeutige fortlaufende ID)
|
|
// - Level string ("INFO", "WARN", "ERROR", "FATAL")
|
|
// - Message string (Beschreibung des Ereignisses)
|
|
// - Source string (z.B. "auth-service", "payment-api")
|
|
type LogRecord struct {
|
|
// TODO: Ergänze die Struct-Felder
|
|
ID int
|
|
Level string
|
|
Message string
|
|
Source string
|
|
}
|
|
|
|
// 🎯 TODO 2: Implementiere den Generator 'ProduceLogs'
|
|
// Parameter:
|
|
// - records: Ein Slice von LogRecords
|
|
// Rückgabe:
|
|
// - Ein Receive-Only Channel (<-chan LogRecord)
|
|
//
|
|
// Anforderungen:
|
|
// 1. Erstelle einen Channel 'out' mit Puffergröße len(records) (mindestens 1).
|
|
// 2. Starte eine Goroutine, die:
|
|
// - Mit 'defer close(out)' sicherstellt, dass der Channel nach getaner Arbeit geschlossen wird.
|
|
// - Über 'records' iteriert und jedes Element in 'out' sendet.
|
|
// 3. Gib den Channel 'out' sofort an den Aufrufer zurück.
|
|
func ProduceLogs(records []LogRecord) <-chan LogRecord {
|
|
// TODO: Generator-Goroutine starten und out-Channel zurückgeben
|
|
return nil
|
|
}
|
|
|
|
// 🎯 TODO 3: Implementiere die Pipeline-Stufe 'FilterLogs'
|
|
// Parameter:
|
|
// - in: Receive-Only Channel (<-chan LogRecord)
|
|
// - targetLevel: Der gesuchte Log-Level (z.B. "ERROR")
|
|
// Rückgabe:
|
|
// - Ein Receive-Only Channel (<-chan LogRecord) mit gefilterten Einträgen
|
|
//
|
|
// Anforderungen:
|
|
// 1. Erstelle einen Ausgangskanal 'out' (z.B. Puffergröße 10).
|
|
// 2. Starte eine Goroutine, die:
|
|
// - 'defer close(out)' aufruft.
|
|
// - Mit 'for record := range in' über alle eingehenden Logs iteriert.
|
|
// - Wenn 'record.Level == targetLevel' ist, sende 'record' in 'out'.
|
|
// 3. Gib 'out' zurück.
|
|
func FilterLogs(in <-chan LogRecord, targetLevel string) <-chan LogRecord {
|
|
// TODO: Filter-Goroutine starten und gefilterten out-Channel zurückgeben
|
|
return nil
|
|
}
|
|
|
|
// 🎯 TODO 4: Implementiere den Consumer 'CountLogsByLevel'
|
|
// Parameter:
|
|
// - in: Receive-Only Channel (<-chan LogRecord)
|
|
// Rückgabe:
|
|
// - Eine Map mit der Anzahl der Logs pro Level, z.B. {"INFO": 5, "ERROR": 2}
|
|
//
|
|
// Anforderungen:
|
|
// 1. Initialisiere eine Map: counts := make(map[string]int).
|
|
// 2. Iteriere mit 'for record := range in' bis der Channel geschlossen wird.
|
|
// 3. Erhöhe für jedes Level den entsprechenden Zähler.
|
|
// 4. Gib 'counts' zurück.
|
|
func CountLogsByLevel(in <-chan LogRecord) map[string]int {
|
|
// TODO: Channel auslesen und Vorkommen aggregieren
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
fmt.Println("=== Go 10: Channels & Datenfluss ===")
|
|
|
|
sampleLogs := []LogRecord{
|
|
{ID: 1, Level: "INFO", Message: "Service gestartet", Source: "gateway"},
|
|
{ID: 2, Level: "WARN", Message: "Hohe Speicherauslastung", Source: "db"},
|
|
{ID: 3, Level: "ERROR", Message: "Verbindungsabbruch", Source: "db"},
|
|
{ID: 4, Level: "INFO", Message: "User Login", Source: "auth"},
|
|
{ID: 5, Level: "ERROR", Message: "Timeout bei Zahlung", Source: "payment"},
|
|
}
|
|
|
|
// 1. Pipeline aufbauen: Produce -> Filter -> Collect
|
|
stream := ProduceLogs(sampleLogs)
|
|
errorsOnly := FilterLogs(stream, "ERROR")
|
|
|
|
fmt.Println("Gefilterte ERROR-Logs:")
|
|
for errLog := range errorsOnly {
|
|
fmt.Printf(" 🚨 [%d] %s: %s (Source: %s)\n", errLog.ID, errLog.Level, errLog.Message, errLog.Source)
|
|
}
|
|
}
|