/api/task/cancel/{id}

# Simple cancellation request
curl -X POST "http://localhost:8080/api/task/cancel/a7f8c9d1-e234-56b7-8901-23c45de67f89"

# Cancel task and check response status
TASK_ID="a7f8c9d1-e234-56b7-8901-23c45de67f89"
API_HOST="http://localhost:8080"

# Request cancellation
RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$API_HOST/api/task/cancel/$TASK_ID")
HTTP_CODE=$(echo "$RESPONSE" | tail -n 1)
BODY=$(echo "$RESPONSE" | head -n -1)

echo "HTTP Status: $HTTP_CODE"
echo "Response: $BODY" | jq '.'

# If successful, verify cancellation
if [ "$HTTP_CODE" = "200" ]; then
    echo "Cancellation requested successfully"

    # Poll until cancelled
    while true; do
        STATUS_RESPONSE=$(curl -s "$API_HOST/api/task/status/$TASK_ID")
        STATE=$(echo "$STATUS_RESPONSE" | jq -r '.state')

        echo "Current state: $STATE"

        if [ "$STATE" = "CANCELLED" ]; then
            echo "Task cancelled successfully"
            break
        fi

        sleep 1
    done
else
    echo "Cancellation failed"
fi

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

const apiHost = "http://localhost:8080"

type CancelResponse struct {
    TaskID  string `json:"task_id"`
    Status  string `json:"status"`
    Message string `json:"message"`
}

type ErrorResponse struct {
    Error   string `json:"error"`
    Message string `json:"message"`
    TaskID  string `json:"task_id"`
}

type TaskStatus struct {
    TaskID     string `json:"task_id"`
    State      string `json:"state"`
    IsFinished bool   `json:"is_finished"`
}

func cancelTask(taskID string) error {
    // Send cancellation request
    url := fmt.Sprintf("%s/api/task/cancel/%s", apiHost, taskID)
    resp, err := http.Post(url, "application/json", nil)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }

    if resp.StatusCode == http.StatusOK {
        var result CancelResponse
        if err := json.Unmarshal(body, &result); err != nil {
            return err
        }
        fmt.Printf("Cancellation requested: %s\n", result.Message)

        // Wait for cancellation to complete
        return waitForCancellation(taskID)

    } else {
        var errResp ErrorResponse
        if err := json.Unmarshal(body, &errResp); err != nil {
            return err
        }
        return fmt.Errorf("%s: %s", errResp.Error, errResp.Message)
    }
}

func waitForCancellation(taskID string) error {
    maxAttempts := 30 // 30 seconds

    for i := 0; i < maxAttempts; i++ {
        statusURL := fmt.Sprintf("%s/api/task/status/%s", apiHost, taskID)
        resp, err := http.Get(statusURL)
        if err != nil {
            return err
        }

        body, err := io.ReadAll(resp.Body)
        resp.Body.Close()

        if err != nil {
            return err
        }

        var task TaskStatus
        if err := json.Unmarshal(body, &task); err != nil {
            return err
        }

        fmt.Printf("Task state: %s\n", task.State)

        if task.State == "CANCELLED" {
            fmt.Println("Task successfully cancelled")
            return nil
        }

        if task.IsFinished && task.State != "CANCELLED" {
            fmt.Println("Task finished before cancellation took effect")
            return nil
        }

        time.Sleep(1 * time.Second)
    }

    return fmt.Errorf("timeout waiting for cancellation")
}

func main() {
    taskID := "a7f8c9d1-e234-56b7-8901-23c45de67f89"

    if err := cancelTask(taskID); err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Println("Task cancelled successfully")
}