forked from mtusi2026/mtusi2026lab2
fix: address lab2 review feedback
This commit is contained in:
+15
-1
@@ -147,7 +147,7 @@ func main() {
|
||||
|
||||
server := &http.Server{
|
||||
Addr: host + ":" + port,
|
||||
Handler: middleware.RequestID(mux),
|
||||
Handler: middleware.RequestID(databaseDeadline(mux)),
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 15 * time.Second,
|
||||
WriteTimeout: 15 * time.Second,
|
||||
@@ -189,3 +189,17 @@ func writeHealthOK(w http.ResponseWriter) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_, _ = w.Write([]byte(`{"status":"ok"}`))
|
||||
}
|
||||
|
||||
// databaseDeadline bounds every API request, including queries on already-open
|
||||
// PostgreSQL connections. The handler maps context/driver errors to HTTP 503.
|
||||
func databaseDeadline(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path == "/health/live" {
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
|
||||
defer cancel()
|
||||
next.ServeHTTP(w, r.WithContext(ctx))
|
||||
})
|
||||
}
|
||||
|
||||
+64
-13
@@ -1,9 +1,11 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
@@ -42,10 +44,7 @@ func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
var req createChatRequest
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
|
||||
if err := decoder.Decode(&req); err != nil {
|
||||
if err := decodeOneObject(r, &req); err != nil {
|
||||
writeError(w, r, http.StatusBadRequest,
|
||||
"invalid_request", "invalid request body")
|
||||
return
|
||||
@@ -132,17 +131,45 @@ func (h *ChatHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
|
||||
chats, err := h.store.ListChatsForUser(r.Context(), currentUser.ID)
|
||||
limit := 50
|
||||
if values, exists := r.URL.Query()["limit"]; exists {
|
||||
if len(values) != 1 {
|
||||
writeError(w, r, 400, "invalid_request", "invalid limit")
|
||||
return
|
||||
}
|
||||
n, err := strconv.Atoi(values[0])
|
||||
if err != nil || n < 1 || n > 100 {
|
||||
writeError(w, r, 400, "invalid_request", "limit must be between 1 and 100")
|
||||
return
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
var cursorTime *time.Time
|
||||
var cursorID *uuid.UUID
|
||||
if values, exists := r.URL.Query()["cursor"]; exists {
|
||||
if len(values) != 1 || values[0] == "" {
|
||||
writeError(w, r, 400, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
t, id, err := decodeChatCursor(values[0], currentUser.ID)
|
||||
if err != nil {
|
||||
writeError(w, r, 400, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
cursorTime = &t
|
||||
cursorID = &id
|
||||
}
|
||||
chats, more, err := h.store.ListChatsPage(r.Context(), currentUser.ID, limit, cursorTime, cursorID)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable,
|
||||
"unavailable", "service unavailable")
|
||||
writeError(w, r, 503, "unavailable", "service unavailable")
|
||||
return
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, chatPage{
|
||||
Items: chats,
|
||||
NextCursor: nil,
|
||||
})
|
||||
var next *string
|
||||
if more && len(chats) > 0 {
|
||||
c := encodeChatCursor(currentUser.ID, chats[len(chats)-1])
|
||||
next = &c
|
||||
}
|
||||
writeJSON(w, 200, chatPage{Items: chats, NextCursor: next})
|
||||
}
|
||||
|
||||
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
|
||||
@@ -176,3 +203,27 @@ func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
writeJSON(w, http.StatusOK, chat)
|
||||
}
|
||||
|
||||
func encodeChatCursor(userID uuid.UUID, chat model.Chat) string {
|
||||
value := fmt.Sprintf("%s|%s|%s", userID, chat.CreatedAt.Format(time.RFC3339Nano), chat.ID)
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(value))
|
||||
}
|
||||
func decodeChatCursor(cursor string, userID uuid.UUID) (time.Time, uuid.UUID, error) {
|
||||
data, err := base64.RawURLEncoding.DecodeString(cursor)
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
parts := strings.Split(string(data), "|")
|
||||
if len(parts) != 3 || parts[0] != userID.String() {
|
||||
return time.Time{}, uuid.Nil, fmt.Errorf("invalid cursor")
|
||||
}
|
||||
t, err := time.Parse(time.RFC3339Nano, parts[1])
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
id, err := uuid.Parse(parts[2])
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
return t, id, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// decodeOneObject rejects a second JSON value, trailing garbage and unknown fields.
|
||||
func decodeOneObject(r *http.Request, target any) error {
|
||||
dec := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(target); err != nil {
|
||||
return err
|
||||
}
|
||||
var extra any
|
||||
if err := dec.Decode(&extra); !errors.Is(err, io.EOF) {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return errors.New("multiple JSON values")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func requireEmptyBody(r *http.Request) error {
|
||||
// A whitespace-only body is accepted as empty; any JSON or other bytes are not.
|
||||
data, err := io.ReadAll(io.LimitReader(r.Body, 2))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(data) != 0 {
|
||||
return errors.New("request body must be empty")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
+14
-25
@@ -2,7 +2,6 @@ package handler
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
@@ -86,17 +85,14 @@ func (h *MessageHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
currentUser, _ := middleware.GetCurrentUser(r.Context())
|
||||
|
||||
var req createMessageRequest
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
|
||||
if err := decoder.Decode(&req); err != nil {
|
||||
if err := decodeOneObject(r, &req); err != nil {
|
||||
writeError(w, r, http.StatusBadRequest,
|
||||
"invalid_request", "invalid request body")
|
||||
return
|
||||
}
|
||||
|
||||
textLength := utf8.RuneCountInString(req.Text)
|
||||
if textLength < 1 || textLength > 4000 {
|
||||
if strings.TrimSpace(req.Text) == "" || textLength > 4000 {
|
||||
writeError(w, r, http.StatusBadRequest,
|
||||
"invalid_request", "text must contain from 1 to 4000 characters")
|
||||
return
|
||||
@@ -146,7 +142,7 @@ func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
var cursorID *uuid.UUID
|
||||
|
||||
if raw := r.URL.Query().Get("cursor"); raw != "" {
|
||||
t, id, err := decodeCursor(raw)
|
||||
t, id, err := decodeMessageCursor(raw, chatID)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest,
|
||||
"invalid_request", "invalid cursor")
|
||||
@@ -167,7 +163,7 @@ func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
var nextCursor *string
|
||||
if hasMore && len(items) > 0 {
|
||||
cursor := encodeCursor(items[len(items)-1])
|
||||
cursor := encodeMessageCursor(items[len(items)-1])
|
||||
nextCursor = &cursor
|
||||
}
|
||||
|
||||
@@ -177,35 +173,28 @@ func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
})
|
||||
}
|
||||
|
||||
func encodeCursor(message model.Message) string {
|
||||
value := fmt.Sprintf(
|
||||
"%s|%s",
|
||||
message.CreatedAt.Format(time.RFC3339Nano),
|
||||
message.ID.String(),
|
||||
)
|
||||
// Cursor contains the chat UUID to prevent cross-chat replay.
|
||||
func encodeMessageCursor(message model.Message) string {
|
||||
value := fmt.Sprintf("%s|%s|%s", message.ChatID, message.CreatedAt.Format(time.RFC3339Nano), message.ID)
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(value))
|
||||
}
|
||||
|
||||
func decodeCursor(cursor string) (time.Time, uuid.UUID, error) {
|
||||
func decodeMessageCursor(cursor string, chatID uuid.UUID) (time.Time, uuid.UUID, error) {
|
||||
data, err := base64.RawURLEncoding.DecodeString(cursor)
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
|
||||
parts := strings.SplitN(string(data), "|", 2)
|
||||
if len(parts) != 2 {
|
||||
return time.Time{}, uuid.Nil, fmt.Errorf("invalid cursor")
|
||||
parts := strings.Split(string(data), "|")
|
||||
if len(parts) != 3 || parts[0] != chatID.String() {
|
||||
return time.Time{}, uuid.Nil, fmt.Errorf("invalid cursor for chat")
|
||||
}
|
||||
|
||||
createdAt, err := time.Parse(time.RFC3339Nano, parts[0])
|
||||
t, err := time.Parse(time.RFC3339Nano, parts[1])
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
|
||||
id, err := uuid.Parse(parts[1])
|
||||
id, err := uuid.Parse(parts[2])
|
||||
if err != nil {
|
||||
return time.Time{}, uuid.Nil, err
|
||||
}
|
||||
|
||||
return createdAt, id, nil
|
||||
return t, id, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"github.com/google/uuid"
|
||||
"mtusi2026lab2/internal/model"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestStrictJSON(t *testing.T) {
|
||||
for _, body := range []string{`{"text":"hello"} garbage`, `{"text":"hello"}{"text":"again"}`} {
|
||||
req := httptest.NewRequest("POST", "/", strings.NewReader(body))
|
||||
var v createMessageRequest
|
||||
if err := decodeOneObject(req, &v); err == nil {
|
||||
t.Fatalf("accepted trailing JSON: %q", body)
|
||||
}
|
||||
}
|
||||
}
|
||||
func TestMessageCursorBoundToChat(t *testing.T) {
|
||||
chatA, chatB := uuid.New(), uuid.New()
|
||||
cursor := encodeMessageCursor(model.Message{ID: uuid.New(), ChatID: chatA, CreatedAt: time.Now().UTC()})
|
||||
if _, _, err := decodeMessageCursor(cursor, chatA); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, err := decodeMessageCursor(cursor, chatB); err == nil {
|
||||
t.Fatal("accepted cursor for another chat")
|
||||
}
|
||||
}
|
||||
func TestChatCursorBoundToUser(t *testing.T) {
|
||||
a, b := uuid.New(), uuid.New()
|
||||
cursor := encodeChatCursor(a, model.Chat{ID: uuid.New(), CreatedAt: time.Now().UTC()})
|
||||
if _, _, err := decodeChatCursor(cursor, a); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, err := decodeChatCursor(cursor, b); err == nil {
|
||||
t.Fatal("accepted cursor for another user")
|
||||
}
|
||||
}
|
||||
func TestEmptyLoginBody(t *testing.T) {
|
||||
req := httptest.NewRequest("POST", "/", strings.NewReader(`{"ignored":true}`))
|
||||
if err := requireEmptyBody(req); err == nil {
|
||||
t.Fatal("accepted login body")
|
||||
}
|
||||
}
|
||||
@@ -53,6 +53,11 @@ func (h *SessionHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
`Basic realm="messenger", charset="UTF-8"`,
|
||||
)
|
||||
|
||||
if err := requireEmptyBody(r); err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "request body must be empty")
|
||||
return
|
||||
}
|
||||
|
||||
username, password, ok := r.BasicAuth()
|
||||
if !ok || username == "" || password == "" {
|
||||
writeError(w, r, http.StatusUnauthorized,
|
||||
|
||||
@@ -4,7 +4,6 @@ import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"regexp"
|
||||
@@ -87,10 +86,7 @@ func VerifyPassword(password, encoded string) bool {
|
||||
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
var req createUserRequest
|
||||
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
|
||||
if err := decoder.Decode(&req); err != nil {
|
||||
if err := decodeOneObject(r, &req); err != nil {
|
||||
writeError(w, r, http.StatusBadRequest,
|
||||
"invalid_request", "invalid request body")
|
||||
return
|
||||
|
||||
@@ -199,3 +199,17 @@ func (s *AuthStore) RevokeSession(
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetActiveSessionUserID is the authoritative expiry/revocation check.
|
||||
// Redis only caches the public user profile; it never grants access on its own.
|
||||
func (s *AuthStore) GetActiveSessionUserID(ctx context.Context, token string) (uuid.UUID, error) {
|
||||
var userID uuid.UUID
|
||||
err := s.pool.QueryRow(ctx, `SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>NOW()`, tokenHash(token)).Scan(&userID)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return uuid.Nil, ErrSessionNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return uuid.Nil, fmt.Errorf("validate session: %w", err)
|
||||
}
|
||||
return userID, nil
|
||||
}
|
||||
|
||||
@@ -203,3 +203,43 @@ func (s *ChatStore) ExistsUser(
|
||||
|
||||
// Kept here to document that chat timestamps are stored in UTC.
|
||||
var _ = time.UTC
|
||||
|
||||
// ListChatsPage uses (created_at,id) keyset pagination and fetches limit+1.
|
||||
func (s *ChatStore) ListChatsPage(ctx context.Context, userID uuid.UUID, limit int, cursorTime *time.Time, cursorID *uuid.UUID) ([]model.Chat, bool, error) {
|
||||
var rows pgx.Rows
|
||||
var err error
|
||||
if cursorTime == nil || cursorID == nil {
|
||||
rows, err = s.pool.Query(ctx, `SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE cm.user_id=$1 ORDER BY c.created_at,c.id LIMIT $2`, userID, limit+1)
|
||||
} else {
|
||||
rows, err = s.pool.Query(ctx, `SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE cm.user_id=$1 AND (c.created_at,c.id)>($2,$3) ORDER BY c.created_at,c.id LIMIT $4`, userID, *cursorTime, *cursorID, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, false, fmt.Errorf("list chats: %w", err)
|
||||
}
|
||||
chats := make([]model.Chat, 0, limit+1)
|
||||
for rows.Next() {
|
||||
var c model.Chat
|
||||
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
|
||||
rows.Close()
|
||||
return nil, false, err
|
||||
}
|
||||
chats = append(chats, c)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
rows.Close()
|
||||
return nil, false, err
|
||||
}
|
||||
rows.Close()
|
||||
more := len(chats) > limit
|
||||
if more {
|
||||
chats = chats[:limit]
|
||||
}
|
||||
for i := range chats {
|
||||
members, err := s.getMemberIDs(ctx, chats[i].ID)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
chats[i].MemberIDs = members
|
||||
}
|
||||
return chats, more, nil
|
||||
}
|
||||
|
||||
@@ -4,11 +4,13 @@ import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"mtusi2026lab2/internal/model"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
@@ -48,7 +50,7 @@ func cacheKey(token string) string {
|
||||
func (c *SessionCache) Set(
|
||||
ctx context.Context,
|
||||
token string,
|
||||
userID uuid.UUID,
|
||||
user model.User,
|
||||
expiresAt time.Time,
|
||||
) error {
|
||||
ttl := time.Until(expiresAt)
|
||||
@@ -56,33 +58,31 @@ func (c *SessionCache) Set(
|
||||
return nil
|
||||
}
|
||||
|
||||
return c.client.Set(
|
||||
ctx,
|
||||
cacheKey(token),
|
||||
userID.String(),
|
||||
ttl,
|
||||
).Err()
|
||||
payload, err := json.Marshal(user)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return c.client.Set(ctx, cacheKey(token), payload, ttl).Err()
|
||||
}
|
||||
|
||||
func (c *SessionCache) Get(
|
||||
ctx context.Context,
|
||||
token string,
|
||||
) (uuid.UUID, bool, error) {
|
||||
) (model.User, bool, error) {
|
||||
value, err := c.client.Get(ctx, cacheKey(token)).Result()
|
||||
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return uuid.Nil, false, nil
|
||||
return model.User{}, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return uuid.Nil, false, err
|
||||
return model.User{}, false, err
|
||||
}
|
||||
|
||||
userID, err := uuid.Parse(value)
|
||||
if err != nil {
|
||||
return uuid.Nil, false, err
|
||||
var user model.User
|
||||
if err := json.Unmarshal([]byte(value), &user); err != nil {
|
||||
return model.User{}, false, err
|
||||
}
|
||||
|
||||
return userID, true, nil
|
||||
return user, true, nil
|
||||
}
|
||||
|
||||
func (c *SessionCache) Delete(
|
||||
|
||||
@@ -37,38 +37,44 @@ func (s *SessionService) CreateSession(
|
||||
return err
|
||||
}
|
||||
|
||||
// Populate the profile cache best-effort after the authoritative INSERT.
|
||||
if s.cache != nil {
|
||||
cacheCtx, cancel := context.WithTimeout(
|
||||
context.Background(), 2*time.Second,
|
||||
)
|
||||
defer cancel()
|
||||
|
||||
_ = s.cache.Set(cacheCtx, token, userID, expiresAt)
|
||||
user, err := s.db.GetUserByID(ctx, userID)
|
||||
if err == nil {
|
||||
cacheCtx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
|
||||
_ = s.cache.Set(cacheCtx, token, user, expiresAt)
|
||||
cancel()
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *SessionService) GetSessionUser(
|
||||
ctx context.Context,
|
||||
token string,
|
||||
) (model.User, error) {
|
||||
// PostgreSQL remains the source of truth.
|
||||
user, err := s.db.GetSessionUser(ctx, token)
|
||||
func (s *SessionService) GetSessionUser(ctx context.Context, token string) (model.User, error) {
|
||||
// A cheap indexed PostgreSQL check on EVERY request enforces expiry and logout,
|
||||
// even if Redis contains a stale value or its deletion fails.
|
||||
userID, err := s.db.GetActiveSessionUserID(ctx, token)
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
|
||||
// Redis is best-effort and cannot extend a session.
|
||||
if s.cache != nil {
|
||||
cacheCtx, cancel := context.WithTimeout(
|
||||
context.Background(), 2*time.Second,
|
||||
)
|
||||
defer cancel()
|
||||
|
||||
_, _, _ = s.cache.Get(cacheCtx, token)
|
||||
cacheCtx, cancel := context.WithTimeout(ctx, 250*time.Millisecond)
|
||||
cached, hit, err := s.cache.Get(cacheCtx, token)
|
||||
cancel()
|
||||
if err == nil && hit && cached.ID == userID {
|
||||
return cached, nil
|
||||
}
|
||||
}
|
||||
user, err := s.db.GetUserByID(ctx, userID)
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
if s.cache != nil {
|
||||
cacheCtx, cancel := context.WithTimeout(ctx, 250*time.Millisecond)
|
||||
// Conservative short TTL on read-through; session lifetime is still checked in PostgreSQL.
|
||||
_ = s.cache.Set(cacheCtx, token, user, time.Now().Add(30*time.Second))
|
||||
cancel()
|
||||
}
|
||||
|
||||
return user, nil
|
||||
}
|
||||
|
||||
@@ -82,7 +88,7 @@ func (s *SessionService) RevokeSession(
|
||||
|
||||
if s.cache != nil {
|
||||
cacheCtx, cancel := context.WithTimeout(
|
||||
context.Background(), 2*time.Second,
|
||||
context.Background(), 250*time.Millisecond,
|
||||
)
|
||||
defer cancel()
|
||||
|
||||
|
||||
Reference in New Issue
Block a user