#Step 09 — Saga 보상 트랜잭션

package com.example.order;

import io.temporal.activity.ActivityOptions;
import io.temporal.workflow.Saga;
import io.temporal.workflow.Workflow;
import java.time.Duration;

public class OrderWorkflowImpl implements OrderWorkflow {

    private static final ActivityOptions OPTS = ActivityOptions.newBuilder()
            .setStartToCloseTimeout(Duration.ofSeconds(10)).build();

    private final PaymentActivity payment = Workflow.newActivityStub(PaymentActivity.class, OPTS);
    private final InventoryActivity inventory = Workflow.newActivityStub(InventoryActivity.class, OPTS);
    private final ShippingActivity shipping = Workflow.newActivityStub(ShippingActivity.class, OPTS);
    private final NotificationActivity notification = Workflow.newActivityStub(NotificationActivity.class, OPTS);

    @Override
    public String processOrder(OrderRequest req) {
        Saga.Options sagaOptions = new Saga.Options.Builder()
                .setParallelCompensation(false)   // 역순 직렬 보상 (기본값)
                .setContinueWithError(false)      // 보상 중 예외 나면 즉시 중단 (기본값)
                .build();
        Saga saga = new Saga(sagaOptions);

        try {
            // ① 결제
            String paymentId = payment.charge(req.orderId(), req.amount());
            saga.addCompensation(payment::refund, paymentId);

            // ② 재고
            String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
            saga.addCompensation(inventory::release, reservationId);

            // ③ 배송
            String shipmentId = shipping.requestShipment(req.orderId(), req.address());
            saga.addCompensation(shipping::cancelShipment, shipmentId);

            notification.notifyCustomer(req.orderId(), "주문이 완료되었습니다");
            return req.orderId() + " COMPLETED";

        } catch (Exception e) {
            Workflow.getLogger(OrderWorkflowImpl.class)
                    .error("[{}] 실패 — 보상 시작", req.orderId(), e);
            saga.compensate();   // 등록의 역순으로 실행
            throw e;             // ← 이 줄이 없으면 워크플로우가 성공으로 끝난다 (9-8 함정)
        }
    }
}

String paymentId = payment.charge(req.orderId(), req.amount());  // 여기서 paymentId 획득
saga.addCompensation(payment::refund, paymentId);                // 그다음에 등록

saga.addCompensation(payment::refundByOrderId, req.orderId());  // 호출 전에 등록
String paymentId = payment.charge(req.orderId(), req.amount());

@Override
public void refund(String paymentId) {
    PgPayment found = pgClient.findByPaymentId(paymentId);

    if (found == null) {
        // 승인된 게 없다 = 되돌릴 것도 없다. 이것은 정상이다.
        log.info("[refund] paymentId={} 승인 건 없음 — 보상 불필요", paymentId);
        return;
    }
    if (found.status() == PgStatus.REFUNDED) {
        // 이미 환불됨. 무한 재시도로 두 번째 호출된 경우.
        log.info("[refund] paymentId={} 이미 환불됨 — 스킵", paymentId);
        return;
    }
    pgClient.refund(paymentId);
    log.info("[refund] paymentId={} 환불 완료", paymentId);
}

// 정방향: 3번 시도하고 포기 → 빨리 실패해서 보상 단계로 넘어간다
private static final ActivityOptions FORWARD = ActivityOptions.newBuilder()
        .setStartToCloseTimeout(Duration.ofSeconds(10))
        .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(3).build())
        .build();

// 보상: 무한 재시도. 7일 안에는 언젠가 성공한다
private static final ActivityOptions COMPENSATION = ActivityOptions.newBuilder()
        .setStartToCloseTimeout(Duration.ofSeconds(30))
        .setScheduleToCloseTimeout(Duration.ofDays(7))
        .setRetryOptions(RetryOptions.newBuilder()
                .setInitialInterval(Duration.ofSeconds(1))
                .setBackoffCoefficient(2.0)
                .setMaximumInterval(Duration.ofMinutes(10))
                .setMaximumAttempts(0)            // 0 = 무제한
                .build())
        .build();

// 같은 인터페이스, 다른 옵션 → 별개의 스텁이 된다. 인터페이스를 두 벌 만들 필요가 없다.
private final PaymentActivity payment =
        Workflow.newActivityStub(PaymentActivity.class, FORWARD);
private final PaymentActivity paymentC =
        Workflow.newActivityStub(PaymentActivity.class, COMPENSATION);

// ...
String paymentId = payment.charge(req.orderId(), req.amount());
saga.addCompensation(paymentC::refund, paymentId);   // ← 무한 재시도 스텁으로 등록

} catch (Exception e) {
    try {
        saga.compensate();
    } catch (Saga.CompensationException ce) {
        // ce.getCause() 에 첫 번째 보상 실패의 원인이 들어 있다
        Workflow.getLogger(OrderWorkflowImpl.class)
                .error("[{}] 보상 실패 — 수동 개입 필요", req.orderId(), ce);
        // 이 액티비티는 반드시 성공해야 하므로 별도의 무한 재시도 스텁을 씁니다
        opsAlert.raiseManualIntervention(
                req.orderId(),
                "SAGA_COMPENSATION_FAILED",
                ce.getCause() == null ? ce.toString() : ce.getCause().toString());
    }
    throw e;   // 원래 실패 원인을 워크플로우 결과로 전파
}

List<Runnable> compensations = new ArrayList<>();
try {
    String paymentId = payment.charge(req.orderId(), req.amount());
    compensations.add(() -> paymentC.refund(paymentId));

    String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
    compensations.add(() -> inventoryC.release(reservationId));

    String shipmentId = shipping.requestShipment(req.orderId(), req.address());
    compensations.add(() -> shippingC.cancelShipment(shipmentId));

    return req.orderId() + " COMPLETED";

} catch (Exception e) {
    Collections.reverse(compensations);        // ← 역순으로 뒤집고
    RuntimeException collected = null;
    for (Runnable c : compensations) {
        try {
            c.run();
        } catch (RuntimeException ce) {        // ← 실패해도 나머지는 계속
            if (collected == null) collected = new RuntimeException("Compensation failed", ce);
            else collected.addSuppressed(ce);  // ← suppressed 로 모으고
        }
    }
    if (collected != null) e.addSuppressed(collected);
    throw e;
}

package com.example.order;

/*
 * Step 09 — Saga 보상 트랜잭션 / Practice.java
 *
 * 실행 방법:
 *   1) Temporal Server 기동:  temporal server start-dev --db-filename temporal.db --ui-port 8233
 *   2) Worker + 클라이언트:    ./gradlew run -PmainClass=com.example.order.Practice
 *   3) 히스토리 확인:          temporal workflow show -w order-1004
 *
 * 환경: Java 21 / temporal-sdk 1.22.3 / Temporal Server 1.22.4 / CLI 0.11.0
 *
 * 이 파일은 본문 9-1 ~ 9-8 의 모든 코드를 절 번호 주석과 함께 담았습니다.
 * 단일 파일에 static nested class 로 워크플로우·액티비티·구현체를 모두 넣어 그대로 컴파일됩니다.
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowFailedException;
import io.temporal.client.WorkflowOptions;
import io.temporal.common.RetryOptions;
import io.temporal.failure.ApplicationFailure;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.worker.Worker;
import io.temporal.worker.WorkerFactory;
import io.temporal.workflow.Saga;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Practice {

    public static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    // ------------------------------------------------------------------
    // [9-0] 공통 DTO — Java 21 record
    // ------------------------------------------------------------------
    public record OrderRequest(
            String orderId,
            String customerId,
            String sku,
            int qty,
            long amount,
            String address) {
    }

    // ------------------------------------------------------------------
    // [9-0] 액티비티 인터페이스 — 정방향과 보상이 짝을 이룬다
    // ------------------------------------------------------------------
    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod
        String charge(String orderId, long amount);

        @ActivityMethod
        void refund(String paymentId);   // 보상
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod
        String reserve(String orderId, String sku, int qty);

        @ActivityMethod
        void release(String reservationId);   // 보상
    }

    @ActivityInterface
    public interface ShippingActivity {
        @ActivityMethod
        String requestShipment(String orderId, String address);

        @ActivityMethod
        void cancelShipment(String shipmentId);   // 보상
    }

    @ActivityInterface
    public interface NotificationActivity {
        @ActivityMethod
        void notifyCustomer(String orderId, String message);
    }

    @ActivityInterface
    public interface OpsAlertActivity {
        @ActivityMethod
        void raiseManualIntervention(String orderId, String code, String detail);
    }

    // ------------------------------------------------------------------
    // 워크플로우 인터페이스
    // ------------------------------------------------------------------
    @WorkflowInterface
    public interface OrderWorkflow {
        @WorkflowMethod
        String processOrder(OrderRequest req);
    }

    @WorkflowInterface
    public interface ManualSagaWorkflow {
        @WorkflowMethod
        String processOrder(OrderRequest req);
    }

    // ------------------------------------------------------------------
    // [9-6] 정방향과 보상은 재시도 정책이 달라야 한다
    //  - 정방향: 빨리 포기해야 보상 단계로 넘어간다 (maximumAttempts = 3)
    //  - 보상  : 절대 포기하면 안 된다            (maximumAttempts = 0 = 무제한)
    // ------------------------------------------------------------------
    static final ActivityOptions FORWARD = ActivityOptions.newBuilder()
            .setStartToCloseTimeout(Duration.ofSeconds(10))
            .setRetryOptions(RetryOptions.newBuilder()
                    .setInitialInterval(Duration.ofMillis(500))
                    .setBackoffCoefficient(2.0)
                    .setMaximumAttempts(3)
                    // 배송 불가 지역은 재시도해도 결과가 같으므로 즉시 실패시킨다
                    .setDoNotRetry("ShippingUnavailableException")
                    .build())
            .build();

    static final ActivityOptions COMPENSATION = ActivityOptions.newBuilder()
            .setStartToCloseTimeout(Duration.ofSeconds(30))
            .setScheduleToCloseTimeout(Duration.ofDays(7))
            .setRetryOptions(RetryOptions.newBuilder()
                    .setInitialInterval(Duration.ofSeconds(1))
                    .setBackoffCoefficient(2.0)
                    .setMaximumInterval(Duration.ofMinutes(10))
                    .setMaximumAttempts(0)   // 0 = 무제한. 환불 API 가 살아나면 자동 성공
                    .build())
            .build();

    // ==================================================================
    // [9-3] Temporal 의 Saga 클래스를 쓴 표준 구현
    // ==================================================================
    public static class OrderWorkflowImpl implements OrderWorkflow {

        private static final Logger log = Workflow.getLogger(OrderWorkflowImpl.class);

        // 같은 인터페이스로 스텁을 두 벌 만든다. 옵션만 다르다.
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, FORWARD);
        private final PaymentActivity paymentC =
                Workflow.newActivityStub(PaymentActivity.class, COMPENSATION);

        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, FORWARD);
        private final InventoryActivity inventoryC =
                Workflow.newActivityStub(InventoryActivity.class, COMPENSATION);

        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, FORWARD);
        private final ShippingActivity shippingC =
                Workflow.newActivityStub(ShippingActivity.class, COMPENSATION);

        private final NotificationActivity notification =
                Workflow.newActivityStub(NotificationActivity.class, FORWARD);
        private final OpsAlertActivity opsAlert =
                Workflow.newActivityStub(OpsAlertActivity.class, COMPENSATION);

        @Override
        public String processOrder(OrderRequest req) {
            Saga.Options sagaOptions = new Saga.Options.Builder()
                    .setParallelCompensation(false)   // [9-5] 역순 직렬 보상 (기본값)
                    .setContinueWithError(false)      // [9-6] 보상 실패 시 즉시 중단 (기본값)
                    .build();
            Saga saga = new Saga(sagaOptions);

            try {
                // ① 결제
                log.info("[{}] 결제 시작 amount={}", req.orderId(), req.amount());
                String paymentId = payment.charge(req.orderId(), req.amount());
                // [9-4] 반환값(paymentId)이 필요하므로 호출 "후"에 등록한다.
                //       호출 자체가 타임아웃돼도 안전하려면 refund 가 멱등해야 한다.
                saga.addCompensation(paymentC::refund, paymentId);

                // ② 재고
                String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
                saga.addCompensation(inventoryC::release, reservationId);

                // ③ 배송
                String shipmentId = shipping.requestShipment(req.orderId(), req.address());
                saga.addCompensation(shippingC::cancelShipment, shipmentId);

                notification.notifyCustomer(req.orderId(), "주문이 완료되었습니다");
                return req.orderId() + " COMPLETED";

            } catch (Exception e) {
                log.error("[{}] 실패 — 보상 시작", req.orderId(), e);
                try {
                    // [9-5] 등록의 역순으로 실행: cancelShipment → release → refund
                    saga.compensate();
                } catch (Saga.CompensationException ce) {
                    // [9-6] ② 전략: 보상이 실패하면 사람이 개입하도록 알린다
                    log.error("[{}] 보상 실패 — 수동 개입 필요", req.orderId(), ce);
                    opsAlert.raiseManualIntervention(
                            req.orderId(),
                            "SAGA_COMPENSATION_FAILED",
                            ce.getCause() == null ? ce.toString() : ce.getCause().toString());
                }
                // [9-9 함정 3] 이 throw 가 없으면 워크플로우가 COMPLETED 로 끝난다.
                //              원래 실패 원인(e)을 그대로 전파해야 히스토리의 cause 가 보존된다.
                throw e;
            }
        }
    }

    // ==================================================================
    // [9-8] Saga 클래스 없이 List<Runnable> 로 직접 구현하면
    // ==================================================================
    public static class ManualSagaWorkflowImpl implements ManualSagaWorkflow {

        private static final Logger log = Workflow.getLogger(ManualSagaWorkflowImpl.class);

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, FORWARD);
        private final PaymentActivity paymentC =
                Workflow.newActivityStub(PaymentActivity.class, COMPENSATION);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, FORWARD);
        private final InventoryActivity inventoryC =
                Workflow.newActivityStub(InventoryActivity.class, COMPENSATION);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, FORWARD);
        private final ShippingActivity shippingC =
                Workflow.newActivityStub(ShippingActivity.class, COMPENSATION);
        private final NotificationActivity notification =
                Workflow.newActivityStub(NotificationActivity.class, FORWARD);

        @Override
        public String processOrder(OrderRequest req) {
            List<Runnable> compensations = new ArrayList<>();
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                compensations.add(() -> paymentC.refund(paymentId));

                String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
                compensations.add(() -> inventoryC.release(reservationId));

                String shipmentId = shipping.requestShipment(req.orderId(), req.address());
                compensations.add(() -> shippingC.cancelShipment(shipmentId));

                notification.notifyCustomer(req.orderId(), "주문이 완료되었습니다");
                return req.orderId() + " COMPLETED";

            } catch (Exception e) {
                // Saga 클래스가 대신해 주던 일을 손으로 한다:
                //  ① 역순 뒤집기  ② 하나 실패해도 계속  ③ suppressed 로 수집
                Collections.reverse(compensations);
                RuntimeException collected = null;
                for (Runnable c : compensations) {
                    try {
                        c.run();
                    } catch (RuntimeException ce) {
                        log.error("[{}] 보상 하나 실패 — 나머지는 계속", req.orderId(), ce);
                        if (collected == null) {
                            collected = new RuntimeException("Compensation failed", ce);
                        } else {
                            collected.addSuppressed(ce);
                        }
                    }
                }
                if (collected != null) {
                    e.addSuppressed(collected);
                }
                throw e;
            }
        }
    }

    // ==================================================================
    // 액티비티 구현 — 9-4 의 멱등성이 핵심
    // ==================================================================

    /** [9-4] 외부 PG 를 흉내 낸 가짜 클라이언트. 멱등 키로 승인 건을 관리한다. */
    public static class FakePgClient {
        public enum PgStatus { APPROVED, REFUNDED }

        public record PgPayment(String paymentId, long amount, PgStatus status) {
        }

        private final Map<String, PgPayment> byKey = new ConcurrentHashMap<>();

        /** 같은 멱등 키로 두 번 호출해도 같은 paymentId 를 돌려준다 (at-least-once 방어) */
        public PgPayment approve(String idempotencyKey, long amount) {
            return byKey.computeIfAbsent(idempotencyKey,
                    k -> new PgPayment("pay_" + Integer.toHexString(k.hashCode() & 0xffff),
                            amount, PgStatus.APPROVED));
        }

        public PgPayment findByPaymentId(String paymentId) {
            return byKey.values().stream()
                    .filter(p -> p.paymentId().equals(paymentId))
                    .findFirst()
                    .orElse(null);
        }

        public void refund(String paymentId) {
            byKey.replaceAll((k, v) -> v.paymentId().equals(paymentId)
                    ? new PgPayment(v.paymentId(), v.amount(), PgStatus.REFUNDED)
                    : v);
        }
    }

    public static class PaymentActivityImpl implements PaymentActivity {

        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(PaymentActivityImpl.class);
        private final FakePgClient pg = new FakePgClient();

        @Override
        public String charge(String orderId, long amount) {
            // [9-4] 멱등 키는 orderId 기반. UUID.randomUUID() 는 재시도마다 달라지므로 절대 금지.
            FakePgClient.PgPayment p = pg.approve(orderId, amount);
            log.info("[charge] orderId={} amount={} -> {}", orderId, amount, p.paymentId());
            return p.paymentId();
        }

        @Override
        public void refund(String paymentId) {
            // [9-4] 멱등 보상의 정본 — 조기 반환 두 개가 핵심이다.
            FakePgClient.PgPayment found = pg.findByPaymentId(paymentId);

            if (found == null) {
                // 규칙 ①: 대상이 없으면 조용히 성공한다.
                // "결제가 아예 안 됐다" = 이미 원하는 상태(돈이 안 빠진 상태)이므로 성공.
                // 여기서 예외를 던지면 보상 단계가 통째로 막힌다.
                log.info("[refund] paymentId={} 승인 건 없음 — 보상 불필요", paymentId);
                return;
            }
            if (found.status() == FakePgClient.PgStatus.REFUNDED) {
                // 규칙 ②: 이미 처리됐으면 조용히 성공한다.
                // 보상은 무한 재시도이므로 두 번 이상 불릴 수 있다. 여기서 안 막으면 이중 환불.
                log.info("[refund] paymentId={} 이미 환불됨 — 스킵", paymentId);
                return;
            }
            pg.refund(paymentId);
            log.info("[refund] paymentId={} 환불 완료", paymentId);
        }
    }

    public static class InventoryActivityImpl implements InventoryActivity {

        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(InventoryActivityImpl.class);
        private final Map<String, Boolean> reservations = new ConcurrentHashMap<>();

        @Override
        public String reserve(String orderId, String sku, int qty) {
            String rid = "rsv_" + Integer.toHexString((orderId + sku).hashCode() & 0xfff);
            reservations.put(rid, true);   // 같은 orderId+sku 면 같은 id — 멱등
            log.info("[reserve] sku={} qty={} -> {}", sku, qty, rid);
            return rid;
        }

        @Override
        public void release(String reservationId) {
            Boolean held = reservations.get(reservationId);
            if (held == null || !held) {
                log.info("[release] reservationId={} 홀드 없음 — 보상 불필요", reservationId);
                return;   // 멱등
            }
            reservations.put(reservationId, false);
            log.info("[release] reservationId={} 해제 완료", reservationId);
        }
    }

    public static class ShippingActivityImpl implements ShippingActivity {

        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(ShippingActivityImpl.class);
        private final Map<String, Boolean> shipments = new HashMap<>();

        @Override
        public String requestShipment(String orderId, String address) {
            // [9-7] 도서산간이면 재시도 불가 예외 — order-1004 시나리오를 만든다
            if (address != null && address.contains("도서산간")) {
                log.error("[requestShipment] 배송 불가 지역: {}", address);
                throw ApplicationFailure.newNonRetryableFailure(
                        "배송 불가 지역: " + address, "ShippingUnavailableException");
            }
            String sid = "shp_" + Integer.toHexString(orderId.hashCode() & 0xfff);
            shipments.put(sid, true);
            log.info("[requestShipment] orderId={} -> {}", orderId, sid);
            return sid;
        }

        @Override
        public void cancelShipment(String shipmentId) {
            if (!Boolean.TRUE.equals(shipments.get(shipmentId))) {
                log.info("[cancelShipment] shipmentId={} 배송 건 없음 — 보상 불필요", shipmentId);
                return;   // 멱등
            }
            shipments.put(shipmentId, false);
            log.info("[cancelShipment] shipmentId={} 취소 완료", shipmentId);
        }
    }

    public static class NotificationActivityImpl implements NotificationActivity {
        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(NotificationActivityImpl.class);

        @Override
        public void notifyCustomer(String orderId, String message) {
            log.info("[notifyCustomer] orderId={} message={}", orderId, message);
        }
    }

    public static class OpsAlertActivityImpl implements OpsAlertActivity {
        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(OpsAlertActivityImpl.class);

        @Override
        public void raiseManualIntervention(String orderId, String code, String detail) {
            // 실무에서는 PagerDuty / Slack / 운영 DB 의 manual_intervention 테이블로
            log.error("[MANUAL] orderId={} code={} detail={}", orderId, code, detail);
        }
    }

    // ==================================================================
    // main — Worker 기동 + order-1004 실행
    // ==================================================================
    public static void main(String[] args) {
        WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();
        WorkflowClient client = WorkflowClient.newInstance(service);
        WorkerFactory factory = WorkerFactory.newInstance(client);

        Worker worker = factory.newWorker(TASK_QUEUE);
        worker.registerWorkflowImplementationTypes(
                OrderWorkflowImpl.class, ManualSagaWorkflowImpl.class);
        worker.registerActivitiesImplementations(
                new PaymentActivityImpl(),
                new InventoryActivityImpl(),
                new ShippingActivityImpl(),
                new NotificationActivityImpl(),
                new OpsAlertActivityImpl());
        factory.start();

        // [9-5] 배송 단계에서 실패하는 주문 — 보상 2개가 역순으로 실행된다
        OrderRequest req = new OrderRequest(
                "1004", "C-77", "SKU-77", 1, 39000,
                "제주특별자치도 서귀포시 도서산간");

        OrderWorkflow wf = client.newWorkflowStub(
                OrderWorkflow.class,
                WorkflowOptions.newBuilder()
                        .setTaskQueue(TASK_QUEUE)
                        .setWorkflowId("order-" + req.orderId())
                        .build());

        try {
            String result = wf.processOrder(req);
            System.out.println("결과: " + result);
        } catch (WorkflowFailedException e) {
            // 실패로 끝나는 것이 정상 동작이다.
            // 보상이 모두 끝난 뒤 원래 실패 원인이 여기로 전파된다.
            System.out.println("예상된 실패: " + e.getCause().getMessage());
            System.out.println("이제 확인하세요: temporal workflow show -w order-" + req.orderId());
        }

        System.exit(0);
    }
}

package com.example.order;

/*
 * Step 09 — Saga 보상 트랜잭션 / Exercise.java
 *
 * 6문제입니다. `// TODO: 여기에 작성` 자리를 채우세요.
 * 정답은 Solution.java 에 있습니다. 반드시 먼저 풀어 보세요.
 *
 * 실행: ./gradlew run -PmainClass=com.example.order.Exercise
 *
 * ⚠️ 주의 — 문제마다 워크플로우 ID 가 다릅니다(order-2001 ~ order-2006).
 *    같은 ID 로 재실행하면 WorkflowExecutionAlreadyStarted 가 납니다.
 *    다시 돌리려면: temporal workflow terminate -w order-2001 --reason retry
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.common.RetryOptions;
import io.temporal.workflow.Saga;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Exercise {

    public static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    public record OrderRequest(String orderId, String customerId, String sku,
                               int qty, long amount, String address) {
    }

    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod String charge(String orderId, long amount);
        @ActivityMethod void refund(String paymentId);
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod String reserve(String orderId, String sku, int qty);
        @ActivityMethod void release(String reservationId);
    }

    @ActivityInterface
    public interface ShippingActivity {
        @ActivityMethod String requestShipment(String orderId, String address);
        @ActivityMethod void cancelShipment(String shipmentId);
    }

    @ActivityInterface
    public interface OpsAlertActivity {
        @ActivityMethod void raiseManualIntervention(String orderId, String code, String detail);
    }

    // ==================================================================
    // 문제 1 — Saga 클래스 없이 List<Runnable> 로 보상을 구현하세요.
    //
    //  요구사항:
    //   (a) 성공한 단계만 보상 목록에 쌓는다
    //   (b) 실패하면 역순으로 실행한다
    //   (c) 보상 하나가 실패해도 나머지는 계속 실행한다
    //   (d) 실패한 보상들은 suppressed 예외로 모아 원래 예외에 붙인다
    //   (e) 마지막에 원래 예외를 다시 던진다
    //
    //  실행 후 확인: temporal workflow show -w order-2001
    //   → ActivityTaskScheduled 순서가 Charge, Reserve, RequestShipment,
    //     Release, Refund 여야 합니다.
    // ==================================================================
    @WorkflowInterface
    public interface Q1ManualSagaWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q1Impl implements Q1ManualSagaWorkflow {

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            List<Runnable> compensations = new ArrayList<>();
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                // TODO: 여기에 작성 — 결제 보상 등록

                String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
                // TODO: 여기에 작성 — 재고 보상 등록

                String shipmentId = shipping.requestShipment(req.orderId(), req.address());
                // TODO: 여기에 작성 — 배송 보상 등록

                return req.orderId() + " COMPLETED";

            } catch (Exception e) {
                // TODO: 여기에 작성 — (b)(c)(d)(e) 를 모두 만족하는 보상 루프
                throw e;
            }
        }
    }

    // ==================================================================
    // 문제 2 — refund / release 를 멱등하게 고치세요.
    //
    //  아래 FakePgClient 는 일부러 까다롭게 만들어 두었습니다:
    //   - findByPaymentId 는 등록되지 않은 키에 null 을 반환합니다
    //   - refund 를 이미 환불된 건에 호출하면 DuplicateRefundException 을 던집니다
    //  즉 멱등하게 고치지 않으면 반드시 터집니다.
    //
    //  요구사항: "대상 없음" 과 "이미 처리됨" 을 모두 정상 종료(return)로 처리
    // ==================================================================
    public static class DuplicateRefundException extends RuntimeException {
        public DuplicateRefundException(String m) { super(m); }
    }

    public static class FakePgClient {
        public enum PgStatus { APPROVED, REFUNDED }
        public record PgPayment(String paymentId, long amount, PgStatus status) {}

        private final Map<String, PgPayment> store = new ConcurrentHashMap<>();

        public PgPayment approve(String idempotencyKey, long amount) {
            return store.computeIfAbsent(idempotencyKey,
                    k -> new PgPayment("pay_" + Integer.toHexString(k.hashCode() & 0xffff),
                            amount, PgStatus.APPROVED));
        }

        public PgPayment findByPaymentId(String paymentId) {
            return store.values().stream()
                    .filter(p -> p.paymentId().equals(paymentId))
                    .findFirst().orElse(null);
        }

        public void refund(String paymentId) {
            PgPayment p = findByPaymentId(paymentId);
            if (p == null) {
                throw new IllegalArgumentException("존재하지 않는 결제 건: " + paymentId);
            }
            if (p.status() == PgStatus.REFUNDED) {
                throw new DuplicateRefundException("이미 환불됨: " + paymentId);
            }
            store.replaceAll((k, v) -> v.paymentId().equals(paymentId)
                    ? new PgPayment(v.paymentId(), v.amount(), PgStatus.REFUNDED) : v);
        }
    }

    public static class Q2PaymentActivityImpl implements PaymentActivity {
        private final FakePgClient pg = new FakePgClient();

        @Override
        public String charge(String orderId, long amount) {
            return pg.approve(orderId, amount).paymentId();
        }

        @Override
        public void refund(String paymentId) {
            // TODO: 여기에 작성
            //  힌트 — pg.refund() 를 바로 부르지 말고, 먼저 findByPaymentId 로 상태를 확인하세요.
            //         null 이면? REFUNDED 면? 각각 어떻게 해야 "보상이 성공"인가요?
        }
    }

    // ==================================================================
    // 문제 3 — 정방향과 보상에 서로 다른 ActivityOptions 를 적용하세요.
    //
    //  요구사항:
    //   - 정방향: StartToCloseTimeout 10초, maximumAttempts 3
    //   - 보상  : StartToCloseTimeout 30초, ScheduleToCloseTimeout 7일,
    //             maximumAttempts 0(무제한), maximumInterval 10분
    //
    //  실행 후 확인:
    //   temporal workflow show -w order-2003 --output json \
    //     | jq '[.events[] | select(.eventType=="EVENT_TYPE_ACTIVITY_TASK_SCHEDULED")
    //            | {t: .activityTaskScheduledEventAttributes.activityType.name,
    //               a: .activityTaskScheduledEventAttributes.retryPolicy.maximumAttempts}]'
    //   → Charge/Reserve 는 3, Release/Refund 는 0 이어야 합니다.
    // ==================================================================
    public static class Q3Options {
        // TODO: 여기에 작성 — FORWARD 상수
        static final ActivityOptions FORWARD = null;

        // TODO: 여기에 작성 — COMPENSATION 상수
        static final ActivityOptions COMPENSATION = null;
    }

    // ==================================================================
    // 문제 4 — 일부러 버그를 만들어 그 결과를 확인하세요.
    //
    //  아래 워크플로우는 saga.compensate() 뒤에 throw 가 없습니다.
    //  이대로 order-2004 를 배송 실패 주소로 실행한 뒤:
    //    temporal workflow describe -w order-2004
    //  Status 가 무엇으로 나오는지 확인하고, 아래 주석에 답을 쓰세요.
    // ==================================================================
    @WorkflowInterface
    public interface Q4BuggyWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q4Impl implements Q4BuggyWorkflow {
        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10)).build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            Saga saga = new Saga(new Saga.Options.Builder().build());
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                shipping.requestShipment(req.orderId(), req.address());
            } catch (Exception e) {
                saga.compensate();
                // throw e;   ← 일부러 뺐습니다
            }
            return req.orderId() + " COMPLETED";
        }
    }

    // TODO: 여기에 작성 — 아래 세 질문에 답하는 주석을 쓰세요.
    //  (1) temporal workflow describe -w order-2004 의 Status 는?
    //  (2) 이 워크플로우를 자식으로 호출한 부모 워크플로우는 어떻게 판단하나요?
    //  (3) 왜 이 버그는 실패율 대시보드에 잡히지 않나요?
    //
    //  답:
    //

    // ==================================================================
    // 문제 5 — setParallelCompensation(true) 로 바꾸고 히스토리를 관찰하세요.
    //
    //  요구사항: Q5Impl 의 Saga.Options 를 병렬 보상으로 설정
    //
    //  실행 후 확인: temporal workflow show -w order-2005
    //   → 직렬 모드에서는 ActivityTaskScheduled 사이에
    //     WorkflowTaskScheduled/Started/Completed 3개가 끼어 있습니다.
    //     병렬 모드에서는 무엇이 달라지나요?
    // ==================================================================
    @WorkflowInterface
    public interface Q5ParallelWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q5Impl implements Q5ParallelWorkflow {
        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10)).build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            // TODO: 여기에 작성 — 병렬 보상 옵션
            Saga.Options sagaOptions = null;
            Saga saga = new Saga(sagaOptions);

            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                String rid = inventory.reserve(req.orderId(), req.sku(), req.qty());
                saga.addCompensation(inventory::release, rid);
                String sid = shipping.requestShipment(req.orderId(), req.address());
                saga.addCompensation(shipping::cancelShipment, sid);
                throw new RuntimeException("보상을 관찰하기 위한 강제 실패");
            } catch (Exception e) {
                saga.compensate();
                throw e;
            }
        }
    }

    // ==================================================================
    // 문제 6 — Saga.CompensationException 을 잡아 운영 알림을 보내되,
    //          워크플로우의 최종 실패 원인은 "원래 실패"로 유지하세요.
    //
    //  요구사항:
    //   - saga.compensate() 를 try 로 감싸 CompensationException 을 잡는다
    //   - opsAlert.raiseManualIntervention(orderId, "SAGA_COMPENSATION_FAILED", 원인) 호출
    //   - 그러고 나서 원래 예외 e 를 던진다 (ce 를 던지면 안 됨)
    //
    //  확인: temporal workflow show -w order-2006 --output json
    //   | jq '.events[-1].workflowExecutionFailedEventAttributes.failure.cause.message'
    //   → 보상 실패가 아니라 원래 실패 메시지가 나와야 합니다.
    // ==================================================================
    @WorkflowInterface
    public interface Q6AlertWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q6Impl implements Q6AlertWorkflow {
        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(1).build())
                .build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);
        private final OpsAlertActivity opsAlert =
                Workflow.newActivityStub(OpsAlertActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            Saga saga = new Saga(new Saga.Options.Builder().build());
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                shipping.requestShipment(req.orderId(), req.address());
                return req.orderId() + " COMPLETED";
            } catch (Exception e) {
                // TODO: 여기에 작성
                throw e;
            }
        }
    }

    // ==================================================================
    // 검증 헬퍼 — 히스토리에서 ActivityTaskScheduled 의 activityType 만 뽑는다.
    // 기대 순서와 assertEquals 로 비교하세요.
    //
    // 사용 예:
    //   List<String> order = verifyCompensationOrder(client, "order-2001");
    //   assert order.equals(List.of("Charge","Reserve","RequestShipment","Release","Refund"));
    // ==================================================================
    public static List<String> verifyCompensationOrder(
            io.temporal.client.WorkflowClient client, String workflowId) {
        List<String> types = new ArrayList<>();
        client.fetchHistory(workflowId).getEvents().forEach(e -> {
            if (e.hasActivityTaskScheduledEventAttributes()) {
                types.add(e.getActivityTaskScheduledEventAttributes()
                        .getActivityType().getName());
            }
        });
        return types;
    }

    public static void main(String[] args) {
        System.out.println("각 문제의 TODO 를 채운 뒤, Practice.java 의 main 을 참고해 "
                + "Worker 를 띄우고 order-2001 ~ order-2006 을 실행하세요.");
    }
}

package com.example.order;

/*
 * Step 09 — Saga 보상 트랜잭션 / Solution.java
 *
 * Exercise.java 6문제의 정답과 해설입니다.
 * 반드시 먼저 풀어 본 뒤에 여세요.
 *
 * 실행: ./gradlew run -PmainClass=com.example.order.Solution
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.common.RetryOptions;
import io.temporal.failure.ApplicationFailure;
import io.temporal.workflow.Saga;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.slf4j.Logger;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Solution {

    public static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    public record OrderRequest(String orderId, String customerId, String sku,
                               int qty, long amount, String address) {
    }

    @ActivityInterface
    public interface PaymentActivity {
        @ActivityMethod String charge(String orderId, long amount);
        @ActivityMethod void refund(String paymentId);
    }

    @ActivityInterface
    public interface InventoryActivity {
        @ActivityMethod String reserve(String orderId, String sku, int qty);
        @ActivityMethod void release(String reservationId);
    }

    @ActivityInterface
    public interface ShippingActivity {
        @ActivityMethod String requestShipment(String orderId, String address);
        @ActivityMethod void cancelShipment(String shipmentId);
    }

    @ActivityInterface
    public interface OpsAlertActivity {
        @ActivityMethod void raiseManualIntervention(String orderId, String code, String detail);
    }

    /* ==================================================================
     * 정답 1 — Saga 클래스 없이 List<Runnable> 로 보상 구현
     * ==================================================================
     *
     * 왜 이 답인가
     * ------------
     * Saga 클래스가 하는 일은 정확히 아래 세 가지입니다.
     *
     *   ① Deque 에 보상을 쌓고 LIFO 로 꺼낸다        → Collections.reverse + for 루프
     *   ② 실패한 보상을 suppressed 로 모은다          → addSuppressed
     *   ③ 직렬/병렬, 중단/계속 4가지 조합을 처리한다   → 여기서는 "직렬 + 계속" 하나만
     *
     * 즉 Saga 는 마법이 아니라 이 20줄의 대체품입니다.
     *
     * 그런데 여기서 반드시 구분해야 할 것이 있습니다.
     * ─────────────────────────────────────────────────────────────
     *  "Worker 가 보상 도중에 죽어도, 재기동한 Worker 가 히스토리를 리플레이해서
     *   'release 는 이미 완료됐고 refund 부터 하면 된다' 를 정확히 알아낸다"
     *  ─ 이 능력은 Saga 클래스가 주는 것이 아니라 Temporal 런타임이 주는 것입니다.
     * ─────────────────────────────────────────────────────────────
     * 그래서 아래 손코딩 버전도 그 마법은 그대로 누립니다.
     * compensations 라는 평범한 ArrayList 조차, 리플레이 때 처음부터 다시 채워지므로
     * 결과적으로 "죽기 직전 상태" 가 완벽히 복원됩니다.
     *
     * 반대로 말하면, Saga 클래스를 쓴다고 해서 얻는 내구성은 없습니다.
     * 보상이 두 개뿐이고 조건 분기가 복잡하다면 손코딩이 더 읽기 좋을 수 있습니다.
     * 중요한 건 클래스 이름이 아니라 세 가지 원칙입니다:
     *   "성공한 것만 역순으로" + "보상은 멱등" + "마지막에 예외를 다시 던진다"
     */
    @WorkflowInterface
    public interface Q1ManualSagaWorkflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q1Solution implements Q1ManualSagaWorkflow {

        private static final Logger log = Workflow.getLogger(Q1Solution.class);

        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10)).build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            List<Runnable> compensations = new ArrayList<>();
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                // (a) 성공한 직후에만 등록한다. charge 가 실패하면 이 줄에 도달하지 않는다.
                compensations.add(() -> payment.refund(paymentId));

                String reservationId = inventory.reserve(req.orderId(), req.sku(), req.qty());
                compensations.add(() -> inventory.release(reservationId));

                String shipmentId = shipping.requestShipment(req.orderId(), req.address());
                compensations.add(() -> shipping.cancelShipment(shipmentId));

                return req.orderId() + " COMPLETED";

            } catch (Exception e) {
                // (b) 역순으로 뒤집는다. 배송취소 → 재고해제 → 결제환불 순이 되어야 한다.
                Collections.reverse(compensations);

                RuntimeException collected = null;
                for (Runnable c : compensations) {
                    try {
                        c.run();
                    } catch (RuntimeException ce) {
                        // (c) 하나 실패해도 나머지는 계속. 여기서 break 하면
                        //     "재고는 풀렸는데 결제는 환불 안 된" 상태로 멈춘다.
                        log.error("[{}] 보상 실패 — 계속 진행", req.orderId(), ce);
                        // (d) suppressed 로 모은다
                        if (collected == null) {
                            collected = new RuntimeException("Compensation failed", ce);
                        } else {
                            collected.addSuppressed(ce);
                        }
                    }
                }
                if (collected != null) {
                    e.addSuppressed(collected);
                }
                // (e) 원래 예외를 다시 던진다. 이 줄이 없으면 워크플로우가 COMPLETED 로 끝난다.
                throw e;
            }
        }
    }

    /* ==================================================================
     * 정답 2 — 멱등한 refund
     * ==================================================================
     *
     * 왜 조기 반환이 두 개인가
     * ------------------------
     * 두 개의 서로 다른 시나리오를 각각 막습니다. 하나라도 빠지면 다음이 터집니다.
     *
     *  ┌──────────────────┬──────────────────────────────────────────────────┐
     *  │ 빠뜨린 체크       │ 언제 터지나                                       │
     *  ├──────────────────┼──────────────────────────────────────────────────┤
     *  │ null 체크 없음    │ charge 가 정말 실패했는데(승인 0건) 보상이 등록된    │
     *  │                  │ 경우. 예컨대 "호출 전 등록" 방식으로 바꿨을 때.      │
     *  │                  │ → IllegalArgumentException → 보상 단계가 통째로 막힘 │
     *  ├──────────────────┼──────────────────────────────────────────────────┤
     *  │ REFUNDED 체크 없음│ 보상이 무한 재시도로 설정돼 있는데 PG 가 환불을      │
     *  │                  │ 처리한 직후 응답이 타임아웃된 경우. 재시도가 발생.    │
     *  │                  │ → DuplicateRefundException, 또는 PG 가 막지 않으면   │
     *  │                  │   실제 이중 환불(고객에게 78,000원)                 │
     *  └──────────────────┴──────────────────────────────────────────────────┘
     *
     * 두 번째가 특히 위험한 이유: 이중 환불은 히스토리에도 예외 로그에도 남지 않습니다.
     * refund 는 두 번 다 "성공" 으로 기록됩니다. 정산 데이터를 대조해야만 발견됩니다.
     *
     * 그리고 9-4 의 "호출 전에 등록? 후에 등록?" 딜레마가 여기서 해소됩니다.
     * 보상이 멱등하면 등록 시점은 더 이상 정답이 하나로 정해지는 문제가 아닙니다.
     * 실무 표준 조합: "호출 후 등록 + 멱등 보상 + 별도의 미아(orphan) 정리 배치".
     */
    public static class FakePgClient {
        public enum PgStatus { APPROVED, REFUNDED }
        public record PgPayment(String paymentId, long amount, PgStatus status) {}

        private final Map<String, PgPayment> store = new ConcurrentHashMap<>();

        public PgPayment approve(String idempotencyKey, long amount) {
            // 멱등 키가 같으면 같은 paymentId. at-least-once 재시도를 이 한 줄이 막는다.
            return store.computeIfAbsent(idempotencyKey,
                    k -> new PgPayment("pay_" + Integer.toHexString(k.hashCode() & 0xffff),
                            amount, PgStatus.APPROVED));
        }

        public PgPayment findByPaymentId(String paymentId) {
            return store.values().stream()
                    .filter(p -> p.paymentId().equals(paymentId))
                    .findFirst().orElse(null);
        }

        public void refund(String paymentId) {
            PgPayment p = findByPaymentId(paymentId);
            if (p == null) throw new IllegalArgumentException("존재하지 않는 결제 건: " + paymentId);
            if (p.status() == PgStatus.REFUNDED) throw new RuntimeException("이미 환불됨: " + paymentId);
            store.replaceAll((k, v) -> v.paymentId().equals(paymentId)
                    ? new PgPayment(v.paymentId(), v.amount(), PgStatus.REFUNDED) : v);
        }
    }

    public static class Q2PaymentActivitySolution implements PaymentActivity {

        private static final org.slf4j.Logger log =
                org.slf4j.LoggerFactory.getLogger(Q2PaymentActivitySolution.class);
        private final FakePgClient pg = new FakePgClient();

        @Override
        public String charge(String orderId, long amount) {
            // orderId 를 멱등 키로. UUID.randomUUID() 는 재시도마다 달라져서 쓸 수 없다.
            // 실무에서는 Activity.getExecutionContext().getInfo().getWorkflowId() 를 쓴다.
            return pg.approve(orderId, amount).paymentId();
        }

        @Override
        public void refund(String paymentId) {
            FakePgClient.PgPayment found = pg.findByPaymentId(paymentId);

            // 규칙 ①: 대상이 없으면 조용히 성공.
            // "되돌릴 게 없다" 는 실패가 아니라 이미 목표 상태에 도달한 것이다.
            if (found == null) {
                log.info("[refund] paymentId={} 승인 건 없음 — 보상 불필요", paymentId);
                return;
            }

            // 규칙 ②: 이미 처리됐으면 조용히 성공.
            // 최종 상태가 원하는 것과 같으므로 성공이다.
            if (found.status() == FakePgClient.PgStatus.REFUNDED) {
                log.info("[refund] paymentId={} 이미 환불됨 — 스킵", paymentId);
                return;
            }

            pg.refund(paymentId);
            log.info("[refund] paymentId={} 환불 완료", paymentId);
        }
    }

    /* ==================================================================
     * 정답 3 — 정방향 / 보상에 서로 다른 ActivityOptions
     * ==================================================================
     *
     * 핵심: 액티비티 인터페이스를 두 벌 만들 필요가 없습니다.
     *       Workflow.newActivityStub 은 "인터페이스 + 옵션" 조합으로 스텁을 만들므로,
     *       같은 인터페이스에 다른 옵션을 주면 별개의 스텁이 나옵니다.
     *
     *   private final PaymentActivity payment  = newActivityStub(PaymentActivity.class, FORWARD);
     *   private final PaymentActivity paymentC = newActivityStub(PaymentActivity.class, COMPENSATION);
     *
     * 왜 정책을 다르게 하나
     *  - 정방향은 "빨리 포기" 해야 합니다. 3번 시도하고 실패해야 보상 단계로 넘어가
     *    고객 돈을 빨리 돌려줄 수 있습니다. 여기서 무한 재시도를 걸면 고객은 하염없이
     *    "결제 처리 중" 화면을 보게 되고 재고도 계속 묶여 있습니다.
     *  - 보상은 "절대 포기 금지" 입니다. 환불 API 가 3일 죽어 있어도 살아나는 순간
     *    자동으로 성공해야 합니다. 개발자가 할 일이 없어야 합니다.
     *
     * 검증:
     *   temporal workflow show -w order-2003 --output json \
     *     | jq '[.events[] | select(.eventType=="EVENT_TYPE_ACTIVITY_TASK_SCHEDULED")
     *            | {t: .activityTaskScheduledEventAttributes.activityType.name,
     *               a: .activityTaskScheduledEventAttributes.retryPolicy.maximumAttempts}]'
     *
     * 기대 출력:
     *   [ {"t":"Charge","a":3}, {"t":"Reserve","a":3}, {"t":"RequestShipment","a":3},
     *     {"t":"Release","a":0}, {"t":"Refund","a":0} ]
     */
    public static class Q3OptionsSolution {
        static final ActivityOptions FORWARD = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .setRetryOptions(RetryOptions.newBuilder()
                        .setInitialInterval(Duration.ofMillis(500))
                        .setBackoffCoefficient(2.0)
                        .setMaximumAttempts(3)
                        .build())
                .build();

        static final ActivityOptions COMPENSATION = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(30))
                .setScheduleToCloseTimeout(Duration.ofDays(7))
                .setRetryOptions(RetryOptions.newBuilder()
                        .setInitialInterval(Duration.ofSeconds(1))
                        .setBackoffCoefficient(2.0)
                        .setMaximumInterval(Duration.ofMinutes(10))
                        .setMaximumAttempts(0)   // 0 = 무제한
                        .build())
                .build();
    }

    /* ==================================================================
     * 정답 4 — throw 누락의 결과
     * ==================================================================
     *
     * (1) Status 는?
     *     temporal workflow describe -w order-2004
     *       Status            COMPLETED
     *       Result            ["2004 COMPLETED"]
     *
     *     결제는 환불됐고 배송은 실패했는데 워크플로우는 성공입니다.
     *
     * (2) 부모 워크플로우는 어떻게 판단하나?
     *     자식 워크플로우로 호출했다면 ChildWorkflowExecutionCompleted 이벤트를 받고
     *     반환값 "2004 COMPLETED" 를 그대로 씁니다. 부모는 다음 단계로 진행합니다.
     *     API 로 호출했다면 클라이언트가 200 OK 와 성공 응답을 받습니다.
     *     → 주문 완료 메일이 나가고, 고객은 "주문 완료" 화면을 봅니다.
     *       배송은 없고 돈은 환불됐는데도.
     *
     * (3) 왜 대시보드에 안 잡히나?
     *     히스토리의 마지막 이벤트가 WorkflowExecutionFailed 가 아니라
     *     WorkflowExecutionCompleted 이기 때문입니다.
     *     - workflow_failed 메트릭이 증가하지 않습니다
     *     - workflow_endtoend_latency 는 정상 범위로 기록됩니다
     *     - 실패율 대시보드는 0% 로 아름답습니다
     *     - temporal workflow list --query 'ExecutionStatus="Failed"' 에도 안 나옵니다
     *     - 재처리 배치의 대상에서도 제외됩니다
     *
     *     즉 시스템 어디에도 이상 신호가 없습니다. 고객 CS 로만 발견됩니다.
     *
     * 방어책 두 가지
     * ─────────────
     *  ① 반환문을 try 블록 안으로 넣으세요.
     *     아래 Q4Solution 처럼 return 이 try 안에 있으면, catch 에서 throw 를 빼먹었을 때
     *     "return 문이 없다" 는 컴파일 에러가 납니다. 실수 자체가 불가능해집니다.
     *  ② Step 11 의 리플레이 테스트에서 실패 시나리오의 최종 상태를 반드시 단언하세요.
     *     assertThrows(WorkflowFailedException.class, () -> wf.processOrder(req));
     */
    @WorkflowInterface
    public interface Q4Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q4Solution implements Q4Workflow {
        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10)).build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            Saga saga = new Saga(new Saga.Options.Builder().build());
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                shipping.requestShipment(req.orderId(), req.address());
                return req.orderId() + " COMPLETED";   // ← return 이 try 안에 있다
            } catch (Exception e) {
                saga.compensate();
                throw e;   // ← 이걸 지우면 "return 문 없음" 컴파일 에러
            }
        }
    }

    /* ==================================================================
     * 정답 5 — 병렬 보상
     * ==================================================================
     *
     * 판정 기준: ActivityTaskScheduled 3개 사이에 WorkflowTaskScheduled 가
     *            "끼어 있지 않다" 는 것.
     *
     * 직렬 모드 (setParallelCompensation(false), 기본값)
     * ────────────────────────────────────────────────
     *   23  ActivityTaskScheduled  [cancelShipment]
     *   24  ActivityTaskStarted
     *   25  ActivityTaskCompleted
     *   26  WorkflowTaskScheduled     ← 워크플로우가 깨어나 다음 명령을 낸다
     *   27  WorkflowTaskStarted
     *   28  WorkflowTaskCompleted
     *   29  ActivityTaskScheduled  [release]
     *   ...
     *   보상 3개에 Workflow Task 왕복이 3번. 총 2.1초.
     *
     * 병렬 모드 (setParallelCompensation(true))
     * ────────────────────────────────────────
     *   22  WorkflowTaskCompleted
     *   23  ActivityTaskScheduled  [cancelShipment]
     *   24  ActivityTaskScheduled  [release]      ← 같은 Workflow Task 에서
     *   25  ActivityTaskScheduled  [refund]       ← 명령 3개를 한 번에 발행
     *   26  ActivityTaskStarted
     *   27  ActivityTaskStarted
     *   28  ActivityTaskStarted
     *   ...
     *   Workflow Task 왕복이 1번. 총 0.8초.
     *
     * ⚠️ 그런데 역순 보장이 사라집니다.
     *    재고 해제가 배송 취소보다 먼저 완료될 수 있습니다.
     *    "배송 취소가 실패했는데 재고는 이미 풀린" 상태가 가능해집니다.
     *    보상들이 서로 완전히 독립일 때만 쓰세요.
     *
     * ⚠️ 추가 함정: 병렬 모드는 setContinueWithError 를 무시합니다.
     *    모든 보상이 이미 시작됐으므로 "실패 시 나머지 중단" 이라는 개념이 성립하지 않습니다.
     *    직렬 전제로 setContinueWithError(false) 를 걸어 뒀다가 병렬로 바꾸면
     *    동작이 조용히 달라집니다.
     */
    @WorkflowInterface
    public interface Q5Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q5Solution implements Q5Workflow {
        private final ActivityOptions opts = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10)).build();
        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, opts);
        private final InventoryActivity inventory =
                Workflow.newActivityStub(InventoryActivity.class, opts);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, opts);

        @Override
        public String processOrder(OrderRequest req) {
            Saga.Options sagaOptions = new Saga.Options.Builder()
                    .setParallelCompensation(true)
                    .build();
            Saga saga = new Saga(sagaOptions);
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                String rid = inventory.reserve(req.orderId(), req.sku(), req.qty());
                saga.addCompensation(inventory::release, rid);
                String sid = shipping.requestShipment(req.orderId(), req.address());
                saga.addCompensation(shipping::cancelShipment, sid);
                throw ApplicationFailure.newNonRetryableFailure(
                        "보상을 관찰하기 위한 강제 실패", "ObserveCompensation");
            } catch (Exception e) {
                saga.compensate();
                throw e;
            }
        }
    }

    /* ==================================================================
     * 정답 6 — CompensationException 처리 + 원인 보존
     * ==================================================================
     *
     * 이중 try 구조가 핵심입니다.
     *
     *   catch (Exception e) {              ← 원래 실패
     *       try { saga.compensate(); }
     *       catch (CompensationException ce) { 알림만 보낸다 }
     *       throw e;                       ← 원래 실패를 던진다 (ce 가 아니라!)
     *   }
     *
     * 순서를 뒤집어 ce 를 던지면 어떻게 되나
     * ─────────────────────────────────────
     * 히스토리의 마지막 이벤트가 이렇게 바뀝니다.
     *
     *   WorkflowExecutionFailed
     *     failure.message: "Compensation failed"
     *     failure.cause.message: "Connection refused: pg-api:443"
     *
     * "왜 이 주문이 실패했는가?" 라는 질문에 "환불 서버 연결 실패" 라고 답하게 됩니다.
     * 진짜 원인인 "배송 불가 지역" 은 어디에도 없습니다.
     * 원인 분석이 불가능해지고, 같은 주소로 들어오는 주문이 계속 실패하는데도
     * 개발자는 PG 서버만 들여다보게 됩니다.
     *
     * 반면 e 를 던지면:
     *   WorkflowExecutionFailed
     *     failure.message: "Activity task failed"
     *     failure.activityFailureInfo.activityType.name: "RequestShipment"
     *     failure.cause.message: "배송 불가 지역: 제주특별자치도 서귀포시 도서산간"
     *
     * 보상 실패는 별도의 알림 채널로 갑니다. 두 정보가 섞이지 않습니다.
     *
     * 그리고 opsAlert 스텁에는 반드시 무한 재시도를 걸어야 합니다.
     * "보상이 실패했다는 알림" 자체가 실패하면 아무도 모르게 됩니다.
     */
    @WorkflowInterface
    public interface Q6Workflow {
        @WorkflowMethod String processOrder(OrderRequest req);
    }

    public static class Q6Solution implements Q6Workflow {

        private static final Logger log = Workflow.getLogger(Q6Solution.class);

        private final ActivityOptions forward = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(10))
                .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(3).build())
                .build();
        // 알림은 절대 실패하면 안 되므로 무한 재시도
        private final ActivityOptions mustSucceed = ActivityOptions.newBuilder()
                .setStartToCloseTimeout(Duration.ofSeconds(30))
                .setScheduleToCloseTimeout(Duration.ofDays(7))
                .setRetryOptions(RetryOptions.newBuilder().setMaximumAttempts(0).build())
                .build();

        private final PaymentActivity payment =
                Workflow.newActivityStub(PaymentActivity.class, forward);
        private final ShippingActivity shipping =
                Workflow.newActivityStub(ShippingActivity.class, forward);
        private final OpsAlertActivity opsAlert =
                Workflow.newActivityStub(OpsAlertActivity.class, mustSucceed);

        @Override
        public String processOrder(OrderRequest req) {
            Saga saga = new Saga(new Saga.Options.Builder()
                    .setContinueWithError(true)   // 하나 실패해도 나머지 보상은 계속
                    .build());
            try {
                String paymentId = payment.charge(req.orderId(), req.amount());
                saga.addCompensation(payment::refund, paymentId);
                shipping.requestShipment(req.orderId(), req.address());
                return req.orderId() + " COMPLETED";

            } catch (Exception e) {
                try {
                    saga.compensate();
                } catch (Saga.CompensationException ce) {
                    log.error("[{}] 보상 실패 — 수동 개입 필요", req.orderId(), ce);
                    opsAlert.raiseManualIntervention(
                            req.orderId(),
                            "SAGA_COMPENSATION_FAILED",
                            ce.getCause() == null ? ce.toString() : ce.getCause().toString());
                    // 여기서 ce 를 던지면 안 된다. 원인이 뒤바뀐다.
                }
                throw e;   // 원래 실패 원인을 워크플로우 결과로 전파
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("Solution.java — 정답 6개. "
                + "Practice.java 의 main 을 참고해 Worker 에 등록하고 실행하세요.");
    }
}