Synchronous Execution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

def load_user(uid):
    # DB/파일 등 외부 의존이 없다고 가정(순수 계산)
    return {"id": uid, "tier": "basic"}

def upgrade(user):
    user["tier"] = "pro"
    return user

def persist(user):
    # 실제론 DB 저장(여기선 프린트로 대체)
    print("saved:", user)

def upgrade_flow(uid):
    user = load_user(uid)          # 1) 로드
    updated = upgrade(user)        # 2) 변환
    persist(updated)               # 3) 저장
    return "OK"

print(upgrade_flow(1))

1
2
3
4
5
6
7
8
9

from pathlib import Path

def read_config_sync(path: str) -> str:
    # 파일 읽기 완료 전까지 이후 코드 진행 없음(블로킹)
    with open(path, "r", encoding="utf-8") as f:
        return f.read()

content = read_config_sync("config.ini")
print("length:", len(content))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def process_batch(batch):
    # 시간이 걸리는 배치 처리(예: 해시 계산/압축)
    return [str(x).upper() for x in batch]

def process_all(items, size=1000):
    out = []
    for i in range(0, len(items), size):     # 배치를 순차 처리
        batch = items[i:i+size]
        out.extend(process_batch(batch))
        # 중간 커밋/체크포인트 가능
    return out

result = process_all(list(range(5000)))
print("processed:", len(result))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import sqlite3

def transfer(conn, from_id, to_id, amount):
    # with 블록: 예외 시 자동 롤백, 정상 종료 시 커밋
    with conn:
        cur = conn.execute("SELECT balance FROM accounts WHERE id=?", (from_id,))
        bal = cur.fetchone()[0]
        if bal < amount:
            raise ValueError("insufficient")
        conn.execute("UPDATE accounts SET balance = balance - ? WHERE id=?", (amount, from_id))
        conn.execute("UPDATE accounts SET balance = balance + ? WHERE id=?", (amount, to_id))
        # 여기까지 모두 성공해야 커밋됨(ACID)

conn = sqlite3.connect(":memory:")
conn.executescript("""
CREATE TABLE accounts(id INTEGER PRIMARY KEY, balance INTEGER);
INSERT INTO accounts VALUES(1, 100), (2, 0);
""")
transfer(conn, 1, 2, 50)
print(conn.execute("SELECT * FROM accounts").fetchall())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# pip install flask
from flask import Flask, request
app = Flask(__name__)

@app.get("/sum")
def calc_sum():
    # 각 요청은 독립 스레드에서 동기적으로 처리됨
    a = int(request.args.get("a", "0"))
    b = int(request.args.get("b", "0"))
    # 긴 작업이 있다면 이 스레드가 블로킹됨
    return {"sum": a + b}

if __name__ == "__main__":
    # threaded=True: 요청마다 스레드 할당(스레드풀 관리)
    app.run(host="0.0.0.0", port=5000, threaded=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# pip install requests
import requests

def fetch_user(uid: int, timeout=(2, 5)):
    # 연결/응답 타임아웃 설정으로 무한 대기 방지
    r = requests.get(f"https://api.example.com/users/{uid}", timeout=timeout)
    r.raise_for_status()
    return r.json()

# 호출이 끝날 때까지 이후 로직 진행 안 됨
# print(fetch_user(1))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import socket, select

def sync_poll_read(host, port):
    sock = socket.socket()
    sock.setblocking(False)             # 논블로킹 소켓
    try:
        sock.connect((host, port))
    except BlockingIOError:
        pass                            # 연결 진행 중

    # 순차 흐름을 유지하면서 준비 여부만 폴링
    while True:
        rlist, _, _ = select.select([sock], [], [], 5)  # 준비되면 반환
        if sock in rlist:
            data = sock.recv(4096)
            if not data: break
            # 읽은 데이터를 동기적으로 가공
            print("got:", len(data))
    sock.close()

# sync_poll_read("example.com", 80)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from flask import Flask, jsonify
import requests

app = Flask(__name__)

@app.route("/track/<user_id>")
def track_user(user_id):
    """
    동기 방식으로 사용자 → 주문 → 배송 상태를 순차 조회
    """
    # 1단계: 사용자 정보 조회 (Blocking)
    user_info = requests.get(f"http://user-service/{user_id}").json()

    # 2단계: 주문 정보 조회 (Blocking)
    order_info = requests.get(f"http://order-service/{user_info['order_id']}").json()

    # 3단계: 배송 상태 조회 (Blocking)
    delivery_info = requests.get(f"http://delivery-service/{order_info['tracking_id']}").json()

    return jsonify({
        "user": user_info,
        "order": order_info,
        "delivery": delivery_info
    })

# Flask 실행
# $ flask run

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

import time
import logging
from typing import Dict, Any

class OrderProcessingSystem:
    """
    동기 실행 기반 주문 처리 시스템
    - 각 단계는 이전 단계 완료 후 실행 (동기 실행의 순차성)
    - 실패 시 명확한 롤백 지점 제공 (동기 실행의 예측 가능성)
    """
    
    def __init__(self):
        self.inventory = {"laptop": 10, "phone": 20}
        self.orders = {}
        
    def process_order_sync(self, order_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        동기적 주문 처리 메인 함수
        - 각 함수 호출은 이전 함수 완료 후 실행 (블로킹 방식)
        """
        order_id = order_data["order_id"]
        
        try:
            # 1단계: 재고 확인 (동기 실행 - 완료까지 대기)
            logging.info(f"재고 확인 시작: {order_id}")
            inventory_result = self._check_inventory(order_data)
            logging.info(f"재고 확인 완료: {order_id}")
            
            # 2단계: 결제 처리 (이전 단계 완료 후 시작)
            logging.info(f"결제 처리 시작: {order_id}")
            payment_result = self._process_payment(order_data)
            logging.info(f"결제 처리 완료: {order_id}")
            
            # 3단계: 배송 준비 (결제 완료 후 시작)
            logging.info(f"배송 준비 시작: {order_id}")
            shipping_result = self._prepare_shipping(order_data)
            logging.info(f"배송 준비 완료: {order_id}")
            
            # 모든 단계 완료 후 최종 처리
            return {
                "status": "success",
                "order_id": order_id,
                "message": "주문이 성공적으로 처리되었습니다"
            }
            
        except Exception as e:
            # 동기 실행의 장점: 명확한 실패 지점 추적
            logging.error(f"주문 처리 실패: {order_id}, 오류: {str(e)}")
            self._rollback_order(order_id)
            return {
                "status": "failed", 
                "order_id": order_id,
                "error": str(e)
            }
    
    def _check_inventory(self, order_data: Dict[str, Any]) -> bool:
        """
        재고 확인 - 블로킹 I/O 시뮬레이션
        - 이 함수가 완료될 때까지 다음 단계 대기
        """
        time.sleep(1)  # 데이터베이스 조회 시뮬레이션 (블로킹)
        
        product = order_data["product"]
        quantity = order_data["quantity"]
        
        if self.inventory.get(product, 0) < quantity:
            raise Exception(f"재고 부족: {product}")
            
        # 재고 예약 (동기적 상태 변경)
        self.inventory[product] -= quantity
        return True
    
    def _process_payment(self, order_data: Dict[str, Any]) -> bool:
        """
        결제 처리 - 외부 결제 게이트웨이 호출 시뮬레이션
        - 결제 완료까지 프로그램 대기 (동기 실행)
        """
        time.sleep(2)  # 결제 게이트웨이 응답 대기 (블로킹)
        
        # 결제 실패 시뮬레이션 (10% 확률)
        import random
        if random.random() < 0.1:
            raise Exception("결제 처리 실패")
            
        return True
    
    def _prepare_shipping(self, order_data: Dict[str, Any]) -> bool:
        """
        배송 준비 - 배송 시스템 연동
        - 배송 정보 등록 완료까지 대기
        """
        time.sleep(1)  # 배송 시스템 등록 시뮬레이션
        
        order_id = order_data["order_id"]
        self.orders[order_id] = {
            "status": "shipping_prepared",
            "timestamp": time.time()
        }
        return True
    
    def _rollback_order(self, order_id: str):
        """
        주문 롤백 - 동기 실행의 명확한 실행 순서 덕분에 
        정확한 롤백 지점 파악 가능
        """
        logging.info(f"주문 롤백 시작: {order_id}")
        # 재고 복구, 결제 취소 등의 롤백 로직
        
# 사용 예시
def main():
    """
    동기 실행 시스템 테스트
    - 각 주문이 순차적으로 처리됨을 확인
    """
    processor = OrderProcessingSystem()
    
    # 여러 주문 동기적 처리
    orders = [
        {"order_id": "ORD001", "product": "laptop", "quantity": 2},
        {"order_id": "ORD002", "product": "phone", "quantity": 1},
        {"order_id": "ORD003", "product": "laptop", "quantity": 5}
    ]
    
    for order in orders:
        # 각 주문은 이전 주문 완료 후 처리 (동기 실행)
        print(f"\n주문 처리 시작: {order['order_id']}")
        result = processor.process_order_sync(order)
        print(f"처리 결과: {result}")
        print(f"현재 재고: {processor.inventory}")

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    main()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from flask import Flask, request

app = Flask(__name__)

@app.route('/process', methods=['POST'])
def process_data():
    """
    동기 실행 예제: 요청받고 DB 읽고 처리 후 응답까지 선형적으로 처리
    - 각 단계가 순차적으로 끝나야 다음 단계로 진행됨
    """
    data = request.json
    # DB에서 데이터 읽기 (동기적 호출)
    result = read_from_db(data['id'])
    processed = do_processing(result)
    return {"result": processed}

def read_from_db(id):
    # 실제 DB 조회 함수 (동기적 처리)
    pass

def do_processing(data):
    # 데이터 처리 함수
    pass

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

@Service
@Transactional
public class AccountTransferService {
    
    @Autowired
    private AccountRepository accountRepository;
    
    @Autowired
    private TransactionRepository transactionRepository;
    
    @Autowired
    private AuditService auditService;
    
    /**
     * 동기 방식 계좌 이체 처리
     * - 모든 단계가 순차적으로 실행됨 (동기 실행의 핵심)
     * - @Transactional로 원자성 보장
     */
    public TransferResult transferMoney(TransferRequest request) {
        String transactionId = generateTransactionId();
        
        try {
            // 1단계: 거래 유효성 검증 (동기 처리 - 완료까지 대기)
            validateTransfer(request);
            auditService.logStart(transactionId, request);
            
            // 2단계: 계좌 잠금 및 잔액 확인 (데드락 방지를 위한 순서 보장)
            Account fromAccount = lockAndGetAccount(request.getFromAccountId());
            Account toAccount = lockAndGetAccount(request.getToAccountId());
            
            // 3단계: 잔액 확인 (동기 실행으로 정확한 시점의 잔액 확인)
            if (fromAccount.getBalance().compareTo(request.getAmount()) < 0) {
                throw new InsufficientBalanceException("잔액 부족");
            }
            
            // 4단계: 출금 처리 (동기적 상태 변경)
            BigDecimal newFromBalance = fromAccount.getBalance().subtract(request.getAmount());
            fromAccount.setBalance(newFromBalance);
            accountRepository.save(fromAccount);  // 즉시 반영 (동기 I/O)
            
            // 5단계: 입금 처리 (출금 완료 후 진행)
            BigDecimal newToBalance = toAccount.getBalance().add(request.getAmount());
            toAccount.setBalance(newToBalance);
            accountRepository.save(toAccount);  // 즉시 반영
            
            // 6단계: 거래 내역 기록 (모든 계좌 변경 완료 후)
            Transaction transaction = new Transaction(
                transactionId,
                request.getFromAccountId(),
                request.getToAccountId(),
                request.getAmount(),
                TransactionStatus.COMPLETED,
                LocalDateTime.now()
            );
            transactionRepository.save(transaction);
            
            // 7단계: 감사 로그 기록 (거래 완료 후)
            auditService.logCompletion(transactionId, fromAccount, toAccount);
            
            // 8단계: 알림 전송 (모든 처리 완료 후)
            sendNotification(request, transactionId);
            
            return new TransferResult(transactionId, "SUCCESS", "이체가 완료되었습니다");
            
        } catch (Exception e) {
            // 동기 실행의 장점: 명확한 실패 지점과 일관된 상태
            auditService.logFailure(transactionId, e.getMessage());
            throw new TransferException("이체 처리 실패: " + e.getMessage(), e);
        }
    }
    
    /**
     * 계좌 잠금 및 조회 - 동시성 제어
     * - 동기 실행으로 락 획득 순서 보장
     */
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    private Account lockAndGetAccount(String accountId) {
        // 데이터베이스 락 획득까지 대기 (블로킹)
        return accountRepository.findByAccountId(accountId)
            .orElseThrow(() -> new AccountNotFoundException("계좌를 찾을 수 없습니다"));
    }
    
    /**
     * 거래 유효성 검증
     * - 각 검증은 이전 검증 완료 후 실행
     */
    private void validateTransfer(TransferRequest request) {
        // 계좌 존재 여부 확인 (동기 DB 조회)
        if (!accountRepository.existsByAccountId(request.getFromAccountId())) {
            throw new AccountNotFoundException("출금 계좌가 존재하지 않습니다");
        }
        
        if (!accountRepository.existsByAccountId(request.getToAccountId())) {
            throw new AccountNotFoundException("입금 계좌가 존재하지 않습니다");
        }
        
        // 한도 확인 (동기 처리)
        if (request.getAmount().compareTo(new BigDecimal("10000000")) > 0) {
            throw new TransferLimitExceededException("이체 한도를 초과했습니다");
        }
        
        // 계좌 상태 확인 (순차 검증)
        Account fromAccount = accountRepository.findByAccountId(request.getFromAccountId()).get();
        if (fromAccount.getStatus() != AccountStatus.ACTIVE) {
            throw new AccountInactiveException("출금 계좌가 비활성 상태입니다");
        }
    }
    
    /**
     * 알림 전송 - 모든 거래 완료 후 실행
     */
    private void sendNotification(TransferRequest request, String transactionId) {
        // SMS 발송 (동기 처리)
        smsService.sendTransferNotification(
            request.getFromAccountId(), 
            request.getAmount(), 
            transactionId
        );
        
        // 이메일 발송 (SMS 완료 후)
        emailService.sendTransferConfirmation(
            request.getFromAccountId(),
            transactionId
        );
    }
}

/**
 * 거래 요청 DTO
 */
@Data
public class TransferRequest {
    private String fromAccountId;
    private String toAccountId;
    private BigDecimal amount;
    private String description;
}

/**
 * 거래 결과 DTO  
 */
@Data
@AllArgsConstructor
public class TransferResult {
    private String transactionId;
    private String status;
    private String message;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

name: CI Pipeline

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Build App
        run: npm run build

  test:
    runs-on: ubuntu-latest
    needs: build
    steps:
      - name: Run Tests
        run: npm test

  deploy:
    runs-on: ubuntu-latest
    needs: test
    steps:
      - name: Deploy to Production
        run: ./deploy.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

from flask import Flask, request, jsonify
import uuid

app = Flask(__name__)

def approve_payment(payment_info):
    """
    결제 승인 API 동기 호출
    - 이 단계가 성공해야 다음 단계로 넘어감
    """
    print(f"결제를 승인 중… {payment_info}")
    return {"status": "success", "transaction_id": str(uuid.uuid4())}

def save_payment_record(transaction_id, amount):
    """
    결제 기록 저장 (동기 DB 호출)
    - 실패 시 예외 발생 → 롤백 처리
    """
    print(f"DB에 결제 기록 저장 중… TXN: {transaction_id}, 금액: {amount}")
    return True

def generate_receipt(transaction_id):
    """
    영수증 생성
    - 반드시 결제 승인과 저장이 끝난 후 실행
    """
    receipt_id = str(uuid.uuid4())
    print(f"영수증 생성 완료: {receipt_id}")
    return {"receipt_id": receipt_id}

@app.route('/payment', methods=['POST'])
def process_payment():
    """
    결제 전체 플로우 - 동기 실행 방식
    결제 승인 → DB 기록 → 영수증 생성 순서로 진행
    """
    data = request.json
    try:
        # 1. 결제 승인
        approval = approve_payment(data)
        if approval["status"] != "success":
            raise Exception("결제 승인 실패")

        # 2. 결제 기록 저장
        if not save_payment_record(approval["transaction_id"], data["amount"]):
            raise Exception("결제 기록 저장 실패")

        # 3. 영수증 생성
        receipt = generate_receipt(approval["transaction_id"])

        return jsonify({
            "status": "success",
            "transaction_id": approval["transaction_id"],
            "receipt": receipt
        })

    except Exception as e:
        # 실패 시 롤백 처리 (실제 구현에서는 DB 트랜잭션 롤백)
        print(f"오류 발생, 롤백 실행: {e}")
        return jsonify({"status": "failure", "reason": str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

import logging
from typing import Dict, Any
from dataclasses import dataclass

@dataclass
class OrderResult:
    success: bool
    order_id: str
    message: str
    details: Dict[str, Any] = None

class OrderProcessingService:
    def __init__(self):
        self.logger = logging.getLogger(__name__)
    
    def process_order(self, order_data: Dict[str, Any]) -> OrderResult:
        """
        주문을 동기적으로 처리하는 메인 함수
        각 단계는 이전 단계의 완료를 기다린 후 실행됨
        """
        try:
            # 1단계: 주문 데이터 검증
            self.logger.info("주문 데이터 검증 시작")
            validation_result = self.validate_order_data(order_data)
            if not validation_result['valid']:
                return OrderResult(False, "", validation_result['error'])
            
            # 2단계: 재고 확인 및 예약
            self.logger.info("재고 확인 및 예약 시작")
            inventory_result = self.check_and_reserve_inventory(order_data['items'])
            if not inventory_result['success']:
                return OrderResult(False, "", inventory_result['error'])
            
            # 3단계: 결제 처리
            self.logger.info("결제 처리 시작")
            payment_result = self.process_payment(order_data['payment_info'])
            if not payment_result['success']:
                # 재고 예약 롤백
                self.rollback_inventory_reservation(inventory_result['reservation_id'])
                return OrderResult(False, "", payment_result['error'])
            
            # 4단계: 배송 정보 생성
            self.logger.info("배송 정보 생성 시작")
            shipping_result = self.create_shipping_info(order_data['shipping_address'])
            if not shipping_result['success']:
                # 결제 및 재고 롤백
                self.rollback_payment(payment_result['transaction_id'])
                self.rollback_inventory_reservation(inventory_result['reservation_id'])
                return OrderResult(False, "", shipping_result['error'])
            
            # 5단계: 주문 완료 처리
            order_id = self.finalize_order({
                'order_data': order_data,
                'inventory': inventory_result,
                'payment': payment_result,
                'shipping': shipping_result
            })
            
            self.logger.info(f"주문 처리 완료: {order_id}")
            return OrderResult(
                True, 
                order_id, 
                "주문이 성공적으로 처리되었습니다.",
                {
                    'payment_id': payment_result['transaction_id'],
                    'shipping_id': shipping_result['shipping_id']
                }
            )
            
        except Exception as e:
            self.logger.error(f"주문 처리 중 예외 발생: {str(e)}")
            return OrderResult(False, "", f"시스템 오류: {str(e)}")
    
    def validate_order_data(self, order_data: Dict[str, Any]) -> Dict[str, Any]:
        """주문 데이터 검증 - 동기 처리"""
        required_fields = ['customer_id', 'items', 'payment_info', 'shipping_address']
        for field in required_fields:
            if field not in order_data:
                return {'valid': False, 'error': f'필수 필드 누락: {field}'}
        return {'valid': True}
    
    def check_and_reserve_inventory(self, items: list) -> Dict[str, Any]:
        """재고 확인 및 예약 - 동기 처리"""
        # 실제 구현에서는 데이터베이스 트랜잭션 사용
        for item in items:
            if not self.check_inventory_availability(item['product_id'], item['quantity']):
                return {'success': False, 'error': f'재고 부족: {item["product_id"]}'}
        
        reservation_id = self.reserve_inventory(items)
        return {'success': True, 'reservation_id': reservation_id}
    
    def process_payment(self, payment_info: Dict[str, Any]) -> Dict[str, Any]:
        """결제 처리 - 동기 처리 (외부 결제 시스템 호출)"""
        # 결제 시스템 API 호출 (블로킹)
        transaction_id = self.call_payment_gateway(payment_info)
        if transaction_id:
            return {'success': True, 'transaction_id': transaction_id}
        return {'success': False, 'error': '결제 처리 실패'}
    
    def create_shipping_info(self, shipping_address: Dict[str, Any]) -> Dict[str, Any]:
        """배송 정보 생성 - 동기 처리"""
        shipping_id = self.generate_shipping_label(shipping_address)
        return {'success': True, 'shipping_id': shipping_id}
    
    # 헬퍼 메서드들 (실제 구현에서는 각각의 서비스와 연동)
    def check_inventory_availability(self, product_id: str, quantity: int) -> bool:
        # 재고 DB 조회
        return True
    
    def reserve_inventory(self, items: list) -> str:
        # 재고 예약 처리
        return "RES_" + str(hash(str(items)))
    
    def call_payment_gateway(self, payment_info: Dict[str, Any]) -> str:
        # 외부 결제 시스템 호출
        return "TXN_" + str(hash(str(payment_info)))
    
    def generate_shipping_label(self, address: Dict[str, Any]) -> str:
        # 배송 라벨 생성
        return "SHIP_" + str(hash(str(address)))
    
    def finalize_order(self, order_details: Dict[str, Any]) -> str:
        # 주문 정보 DB 저장
        return "ORDER_" + str(hash(str(order_details)))
    
    def rollback_inventory_reservation(self, reservation_id: str):
        """재고 예약 롤백"""
        self.logger.info(f"재고 예약 롤백: {reservation_id}")
    
    def rollback_payment(self, transaction_id: str):
        """결제 롤백"""
        self.logger.info(f"결제 롤백: {transaction_id}")

# 사용 예시
if __name__ == "__main__":
    service = OrderProcessingService()
    
    order_data = {
        'customer_id': 'CUST_001',
        'items': [
            {'product_id': 'PROD_001', 'quantity': 2},
            {'product_id': 'PROD_002', 'quantity': 1}
        ],
        'payment_info': {
            'card_number': '****-****-****-1234',
            'amount': 50000
        },
        'shipping_address': {
            'address': '서울시 강남구',
            'zip_code': '12345'
        }
    }
    
    # 동기적 주문 처리
    result = service.process_order(order_data)
    print(f"처리 결과: {result}")