Za što se koristi `context` paket?

Question

Accepted Answer

Paket **`context`** prenosi **signale otkazivanja, rokove (deadline) i vrijednosti vezane uz zahtjev** kroz API granice i goroutine. To je standardni mehanizam za kontrolu životnog vijeka operacija — osobito za otkazivanje rada i propagaciju vremenskih ograničenja kroz niz poziva funkcija.

## Problem koji se rješava

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Stvaranje konteksta

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` izvode podređeni kontekst koji se može otkazati; morate pozvati `defer cancel()` da biste oslobodili njegove resurse.

## Odgovaranje na otkazivanje

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Funkcije provjeravaju `ctx.Done()` (kanal koji se zatvara pri otkazivanju) i zaustavljaju se brzo — tako se otkazivanje zapravo propagira.

## Proslijeđivanje konteksta kroz niz poziva (konvencija)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Kontekst teče prema dolje kroz call stack kao prvi parametar, tako da otkazivanje dostiže svaki sloj (uključujući standardne bibliotečne pozive za baze podataka/HTTP koji prihvaćaju kontekst).

## Vrijednosti vezane uz zahtjev (koristiti sa štednjom)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## Zašto je važno

Paket `context` je fundamentalan za pisanje robustan, proizvodnog Go servisa — to je standardni, idiomatski način rukovanja **otkazivanjem i vremenskim ograničenjima** preko goroutine i API granica.

Njegova primarna vrijednost je sprječavanje besmislenog rada i curenja resursa: kada se klijent odsoji, rokovi isteknu ili server zaustavlja, kontekst propagira signal otkazivanja tako da se svi goroutine i operacije pokrenute za taj zahtjev brzo zaustave umjesto da se beskorisno izvršavaju (ključna obrana protiv curenja goroutine).

Ono je sveprisutno u pravom Go kodu — HTTP serveri, pozivi baza podataka, gRPC i većina mrežnih biblioteka prihvaćaju `context.Context` kao svoj prvi parametar.

Razumijevanje kako stvarati kontekste (`WithTimeout`/`WithCancel`), odgovarati na otkazivanje (`<-ctx.Done()`), pravilo koja se mora pozvati `cancel()` i konvenciju proslijeđivanja konteksta kroz call chain je bitno za bilo koji ozbiljan Go backend rad i čest je tema u intervjuima.