package main import ( "bytes" "context" "crypto/tls" "crypto/x509" "encoding/base64" "encoding/json" "errors" "flag" "fmt" "image" _ "image/jpeg" "io" "net/http" "os" "strings" "time" "github.com/google/uuid" "gitea.privcloud.tech/dizi/mtusi2026lab7/internal/model" ) type apiState struct { BaseURL string `json:"base_url"` CAFile string `json:"ca_file"` Token string `json:"token"` AttachmentID string `json:"attachment_id"` } type apiUser struct { ID string `json:"id"` } type apiSession struct { Token string `json:"token"` } type apiChat struct { ID string `json:"id"` } func runAPIProduce(arguments []string, output io.Writer) error { flags := flag.NewFlagSet("api-produce", flag.ContinueOnError) flags.SetOutput(io.Discard) baseURL := flags.String("base-url", "https://nginx:8443", "messenger base URL") caFile := flags.String("ca-file", "/run/security/public-ca/ca.crt", "trusted CA certificate") if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { return errors.New("usage: lab5experiment api-produce [-base-url URL] [-ca-file PATH]") } client, err := newAPIClient(*caFile) if err != nil { return err } suffix := strings.ReplaceAll(uuid.NewString(), "-", "")[:12] password := "Lab5-" + uuid.NewString() owner, err := registerAPIUser(client, *baseURL, "qa_"+suffix, password) if err != nil { return err } member, err := registerAPIUser(client, *baseURL, "qb_"+suffix, password) if err != nil { return err } token, err := createAPISession(client, *baseURL, "qa_"+suffix, password) if err != nil { return err } chat, err := createAPIChat(client, *baseURL, token, owner.ID, member.ID) if err != nil { return err } fixture, err := pngFixture(320, 200) if err != nil { return err } var attachment model.Attachment response, err := apiRequest( client, http.MethodPost, *baseURL+"/api/v1/chats/"+chat.ID+"/attachments?filename=queued.png", token, "image/png", fixture, &attachment, ) if err != nil { return err } if response.StatusCode != http.StatusAccepted || attachment.Status != model.AttachmentQueued { return fmt.Errorf("upload returned status=%d attachment_status=%s", response.StatusCode, attachment.Status) } messageBody, err := json.Marshal(map[string]any{"text": "", "attachment_ids": []string{attachment.ID}}) if err != nil { return err } response, err = apiRequestWithHeaders( client, http.MethodPost, *baseURL+"/api/v1/chats/"+chat.ID+"/messages", token, "application/json", messageBody, nil, map[string]string{"Idempotency-Key": uuid.NewString()}, ) if err != nil { return err } if response.StatusCode != http.StatusCreated { return fmt.Errorf("link queued attachment returned %d", response.StatusCode) } response, err = apiRequest(client, http.MethodGet, *baseURL+"/api/v1/attachments/"+attachment.ID+"/content", token, "", nil, nil) if err != nil { return err } if response.StatusCode != http.StatusConflict { return fmt.Errorf("queued content returned %d, expected 409", response.StatusCode) } return json.NewEncoder(output).Encode(apiState{ BaseURL: *baseURL, CAFile: *caFile, Token: token, AttachmentID: attachment.ID, }) } func runAPIVerify(arguments []string, input io.Reader, output io.Writer) error { flags := flag.NewFlagSet("api-verify", flag.ContinueOnError) flags.SetOutput(io.Discard) waitTimeout := flags.Duration("wait-timeout", time.Minute, "ready wait timeout") if err := flags.Parse(arguments); err != nil || flags.NArg() != 0 { return errors.New("usage: lab5experiment api-verify [-wait-timeout 1m]") } var state apiState if err := json.NewDecoder(input).Decode(&state); err != nil { return fmt.Errorf("decode API scenario state: %w", err) } client, err := newAPIClient(state.CAFile) if err != nil { return err } ctx, cancel := context.WithTimeout(context.Background(), *waitTimeout) defer cancel() var attachment model.Attachment for { response, err := apiRequest(client, http.MethodGet, state.BaseURL+"/api/v1/attachments/"+state.AttachmentID, state.Token, "", nil, &attachment) if err != nil { return err } if response.StatusCode != http.StatusOK { return fmt.Errorf("attachment metadata returned %d", response.StatusCode) } if attachment.Status == model.AttachmentReady { break } if attachment.Status == model.AttachmentFailed { return fmt.Errorf("attachment failed with %v", attachment.ErrorCode) } if err := wait(ctx, 250*time.Millisecond); err != nil { return err } } if len(attachment.Variants) != 3 { return fmt.Errorf("public variants = %d, expected 3", len(attachment.Variants)) } response, original, err := apiBytes(client, state.BaseURL+"/api/v1/attachments/"+state.AttachmentID+"/content", state.Token) if err != nil { return err } fixture, err := pngFixture(320, 200) if err != nil { return err } if response.StatusCode != http.StatusOK || !bytes.Equal(original, fixture) { return errors.New("original changed after worker and broker restart") } response, thumbnail, err := apiBytes( client, state.BaseURL+"/api/v1/attachments/"+state.AttachmentID+"/content?variant=thumbnail", state.Token, ) if err != nil { return err } if response.StatusCode != http.StatusOK || response.Header.Get("Content-Type") != "image/jpeg" { return errors.New("thumbnail response is invalid") } imageConfig, format, err := image.DecodeConfig(bytes.NewReader(thumbnail)) if err != nil || format != "jpeg" || imageConfig.Width != 256 || imageConfig.Height != 160 { return errors.New("thumbnail dimensions are invalid") } return json.NewEncoder(output).Encode(map[string]any{ "accepted_while_worker_stopped": true, "accepted_before_outbox_publish": true, "linked_while_queued": true, "content_conflict_while_queued": true, "ready_after_api_broker_restart": true, "original_preserved": true, "thumbnail_dimensions": "256x160", }) } func newAPIClient(caFile string) (*http.Client, error) { caPEM, err := os.ReadFile(caFile) if err != nil { return nil, fmt.Errorf("read trusted CA: %w", err) } roots := x509.NewCertPool() if !roots.AppendCertsFromPEM(caPEM) { return nil, errors.New("trusted CA does not contain a certificate") } transport := &http.Transport{TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12, RootCAs: roots}} return &http.Client{Transport: transport, Timeout: 10 * time.Second}, nil } func registerAPIUser(client *http.Client, baseURL, username, password string) (apiUser, error) { body, err := json.Marshal(map[string]string{ "username": username, "display_name": username, "password": password, }) if err != nil { return apiUser{}, err } var user apiUser response, err := apiRequest(client, http.MethodPost, baseURL+"/api/v1/users", "", "application/json", body, &user) if err != nil { return apiUser{}, err } if response.StatusCode != http.StatusCreated { return apiUser{}, fmt.Errorf("register user returned %d", response.StatusCode) } return user, nil } func createAPISession(client *http.Client, baseURL, username, password string) (string, error) { credentials := base64.StdEncoding.EncodeToString([]byte(username + ":" + password)) request, err := http.NewRequest(http.MethodPost, baseURL+"/api/v1/auth/sessions", nil) if err != nil { return "", err } request.Header.Set("Authorization", "Basic "+credentials) response, err := client.Do(request) if err != nil { return "", err } defer func() { _ = response.Body.Close() }() if response.StatusCode != http.StatusCreated { return "", fmt.Errorf("create session returned %d", response.StatusCode) } var session apiSession if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&session); err != nil { return "", err } return session.Token, nil } func createAPIChat(client *http.Client, baseURL, token, ownerID, memberID string) (apiChat, error) { body, err := json.Marshal(map[string]any{ "title": "Lab 5 resilience", "member_ids": []string{ownerID, memberID}, }) if err != nil { return apiChat{}, err } var chat apiChat response, err := apiRequest(client, http.MethodPost, baseURL+"/api/v1/chats", token, "application/json", body, &chat) if err != nil { return apiChat{}, err } if response.StatusCode != http.StatusCreated { return apiChat{}, fmt.Errorf("create chat returned %d", response.StatusCode) } return chat, nil } func apiRequest( client *http.Client, method string, requestURL string, token string, contentType string, body []byte, result any, ) (*http.Response, error) { return apiRequestWithHeaders(client, method, requestURL, token, contentType, body, result, nil) } func apiRequestWithHeaders( client *http.Client, method string, requestURL string, token string, contentType string, body []byte, result any, headers map[string]string, ) (*http.Response, error) { request, err := http.NewRequest(method, requestURL, bytes.NewReader(body)) if err != nil { return nil, err } if token != "" { request.Header.Set("Authorization", "Bearer "+token) } if contentType != "" { request.Header.Set("Content-Type", contentType) } for name, value := range headers { request.Header.Set(name, value) } response, err := client.Do(request) if err != nil { return nil, err } defer func() { _ = response.Body.Close() }() if result != nil && response.StatusCode < http.StatusBadRequest { if err := json.NewDecoder(io.LimitReader(response.Body, 16<<20)).Decode(result); err != nil { return nil, err } } return response, nil } func apiBytes(client *http.Client, requestURL, token string) (*http.Response, []byte, error) { request, err := http.NewRequest(http.MethodGet, requestURL, nil) if err != nil { return nil, nil, err } request.Header.Set("Authorization", "Bearer "+token) response, err := client.Do(request) if err != nil { return nil, nil, err } defer func() { _ = response.Body.Close() }() body, err := io.ReadAll(io.LimitReader(response.Body, 16<<20)) return response, body, err }