X'għandu x-ser l-pakkett `context`?

Question

Accepted Answer

Il-pakkett **`context`** iġib **sinjali ta' kanċellazzjoni, deadline u valuri skopjati tar-richiesta** madwar il-fruntieri tal-API u l-goroutine. Huwa l-mekkaniżmu standard għall-kontroll tal-ħajja tal-operazzjonijiet — speċjalment għall-kanċellazzjoni tal-ħidma u l-propagazzjoni tal-timeout permezz ta' katina ta' sejħat tal-funzjoni.

## Il-problema ewlenija li tsolvi

```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.
```

## Ħolqod contexts

```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` jideridu context ta' iben li jista' jiġi kanċellat; għandek `defer cancel()` biex taħlief ir-risor tiegħu.

## Mrieħa għal kanċellazzjoni

```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)
        }
    }
}
```

Funzjonijiet jiċċekkjaw `ctx.Done()` (channel li jinqata' fuq kanċellazzjoni) u jieqfu minnufih — hekk kif il-kanċellazzjoni proppa tipropagaw.

## Il-passaġġ ta' context permezz ta' katina ta' sejħat (il-konvenzjoni)

```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
}
```

Il-context jiskorri għall-isfel tal-istaqqaħ ta' sejħat bħala l-ewwel parametru, sabiex il-kanċellazzjoni tilħaq kull saff (inkluż il-sejħat DB/HTTP tal-librerija standard li jaqblu l-context).

## Valuri skopjati tar-richiesta (uża b'mod sparing)

```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
```

## Għaliex hija importanti

Il-pakkett `context` huwa fundamentali għall-iktib ta' servizzi Go robust u ta' grad ta' produzzjoni — huwa l-mod standard u idiomatic biex tinġestjoni **kanċellazzjoni u timeout** madwar goroutine u fruntieri tal-API.

Il-valur primaryu tiegħu huwa t-tbegħid tal-ispiża tal-ħidma u telf tar-risor: meta klijent jidkonjetti, deadline jgħaddi, jew server jitqiegħed, context jipropagaw is-sinjal tal-kanċellazzjoni sabiex il-goroutine u l-operazzjonijiet kollha stabbiliiti għal dik ir-richiesta jieqfu minnufih minflok jkomplu jagħmlu ħadd (difża ewlenija kontra telf ta' goroutine).

Hija permezzija fir-realtà ta' Go — servizzi HTTP, sejħat database, gRPC, u ħafna libreriji ta' network jaqblu `context.Context` bħala l-ewwel parametru.

L-fehim ta' kif ħolqod contexts (`WithTimeout`/`WithCancel`), kif mrieħa għal kanċellazzjoni (`<-ctx.Done()`), ir-regola li `cancel()` għandha titħabat, u l-konvenzjoni ta' threading context permezz ta' katinji ta' sejħat hija essenzjali għal kwalunkwe ħidma seria ta' Go backend u suġġett komuni ta' intervista.