Handling Concurrency in Multiple Applications

upstream lotto_backend {
    server lotto-back-1:8080;
    server lotto-back-2:8080;
    server lotto-back-3:8080;
    server lotto-back-4:8080;
}
 
server {
    listen 80;
    server_name localhost;
 
    location / {
        proxy_pass http://lotto_backend/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

lotto-back-1:
  build:
    context: ../
  container_name: lotto-back-1
  ports:
    - "8081:8080"
  depends_on:
    lotto-mysql:
      condition: service_healthy
  volumes:
    - ../build/libs/spring-lotto-0.0.1-SNAPSHOT.jar:/app/app.jar
  environment:
    SERVER_NAME: "lotto-back-1"
    SPRING_PROFILES_ACTIVE: dev
  networks:
    - app-network
  deploy:
    resources:
      limits:
        cpus: '0.5'
        memory: '512M'

const order = http.post(`${baseUrl}/api/orders`, orderPayload, {
  headers: { "Content-Type": "application/json" },
});
 
check(order, {
  "Order creation request successful": (r) => r.status === 200,
});
 
// On successful order creation, extract lottoPublishId and orderId from the response JSON
let orderData = order.json().data || {};
let lottoPublishId = orderData.lottoPublishId;
 
// Wait for payment process
sleep(0.8);
 
// Proceed with payment approval
const paymentPayload = JSON.stringify({
  lottoPublishId: orderData.lottoPublishId,
  purchaseHttpRequest: {
    orderId: orderData.orderId,
    paymentKey: orderData.orderId,
  },
});
 
for (let i = 0; i < 5; i++) {
  requests.push([
    "POST",
    `${baseUrl}/api/tickets`,
    paymentPayload,
    {
      headers: {
        "Content-Type": "application/json",
    },
  }
]);
}
 
const responses = http.batch(requests);

orderValidator.checkOrderValid(lottoPurchaseRequest.toOrderDataRequest())
lottoPublisher.pending(lottoPublishId)
val purchase = purchaseProcessor.purchase(lottoPurchaseRequest.toPurchaseRequest())
val lottoPublish = lottoPublisher.complete(lottoPublishId)
val bill = lottoWriter.saveBill(purchase.getId(),lottoPublishId, authenticated.memberId)
return LottoBillData(
    id = bill.getId()!!,
    purchase = PurchaseData.from(purchase),
    lottoPublish = LottoPublishData.from(lottoPublish)
)

// purchaseProcessor.purchase part
 
class TossPaymentFakeClient(
    private val jdbcTemplate: JdbcTemplate
) : PaymentClient {
    override fun process(request: PurchaseRequest): PurchaseData {
        ifCustomHeaderThrowException()
        Thread.sleep(Random.nextLong(100, 500)) 
        jdbcTemplate.update("INSERT INTO purchase_key (payment_key) VALUES (?)", request.paymentKey)
        return PurchaseData(
            totalAmount = request.amount,
            paymentKey = request.paymentKey,
            orderId = request.orderId,
            status = PurchaseStatus.SUCCESS,
            purchaseProvider = PurchaseProvider.TOSS,
            method = PaymentMethod.CARD,
        )
    }
}

* CREATE TABLE purchase_key (
*     payment_key VARCHAR(50) NOT NULL,
*     PRIMARY KEY (payment_key)
* );

responses.forEach((res, idx) => {
  if (res.status === 200) {
    successCount++;
  } else if (res.status === 400) {
    badRequestCount++;
  } else if (res.status === 500){
    concurrencyCount++;
  }
});
 
// Desired condition: "only 1 request is 200, the other 4 are 400"check({
  successCount,
  badRequestCount,
}, {
  "exactly 1 success and 4 bad requests": (obj) =>
    obj.successCount === 1 && obj.badRequestCount === 4,
});

val isCompleted = publishCompletionStatus.computeIfAbsent(lottoPublishId) { AtomicBoolean(false) }
if (!isCompleted.compareAndSet(false, true)) {
    throw IllegalStateException("Payment is already in progress.")
}
 
orderValidator.checkOrderValid(lottoPurchaseRequest.toOrderDataRequest())
lottoPublisher.pending(lottoPublishId)
val purchase = purchaseProcessor.purchase(lottoPurchaseRequest.toPurchaseRequest())
val lottoPublish = lottoPublisher.complete(lottoPublishId)
val bill = lottoWriter.saveBill(purchase.getId(),lottoPublishId, authenticated.memberId)
return LottoBillData(
    id = bill.getId()!!,
    purchase = PurchaseData.from(purchase),
    lottoPublish = LottoPublishData.from(lottoPublish)
)

//console.log(successCount+"\t"+badRequestCount+"\t"+concurrencyCount);
 
INFO[0015] 1	1	3                                         source=console
INFO[0016] 1	3	1                                         source=console
INFO[0017] 1	4	0                                         source=console
INFO[0017] 1	2	2                                         source=console
INFO[0017] 1	3	1                                         source=console
INFO[0018] 1	1	3                                         source=console
INFO[0018] 1	3	1                                         source=console

    @Modifying
    @Transactional
    @Query("UPDATE LottoPublish lp SET lp.status = :newStatus WHERE lp.id = :id AND lp.status = :oldStatus")
    fun updateStatus(
        @Param("id") id: Long,
        @Param("newStatus") newStatus: LottoPublishStatus,
        @Param("oldStatus") oldStatus: LottoPublishStatus
    ): Int

    @Transaction
    @Write
    fun pending(publishId: Long): LottoPublish {
        val lottoPublish = getLottoPublish(publishId)
        val changed = 
            lottoPublishRepository.updateStatus(publishId, LottoPublishStatus.PENDING, LottoPublishStatus.WAITING)
        if (changed == 0) {
            throw IllegalStateException("Completion is only possible in the payment waiting state")
        }
        return lottoPublish
    }

* CREATE TABLE purchase_key (
*     payment_key VARCHAR(50) NOT NULL,
*     PRIMARY KEY (payment_key)
* );

try {
    jdbcTemplate.update("INSERT INTO purchase_key (payment_key) VALUES (?)", request.paymentKey)
}catch (e : DuplicateKeyException){
    throw PurchaseException(PurchaseExceptionCode.ALREADY_PROCESS,e)
}

fun pending() {
    if (this.status != LottoPublishStatus.WAITING) {
        throw IllegalStateException("Completion is only possible in the payment waiting state")
    }
    this.status = LottoPublishStatus.PENDING
}

@Version
private var version: Long? = null

@Lock(LockModeType.OPTIMISTIC)
@Query("select lp from LottoPublish lp where lp.id = :id")
fun findByIdWithOptimistic(@Param("id") id: Long): LottoPublish?

@Transaction
@Write
fun pending(publishId: Long): LottoPublish {
    val maxAttempts = 3
    for (attempt in 1..maxAttempts) {
        try {
            val lottoPublish = getLottoPublish(publishId)
            lottoPublish.pending()
            return lottoPublish
        } catch (e: StaleObjectStateException) {
            if (attempt == maxAttempts) {
                throw IllegalArgumentException("A concurrent request occurred while changing the PENDING state. The number of retries has been exceeded.", e)
            }
            Thread.sleep(100)
        }
    }
    throw IllegalStateException("Unexpected error during pending()")
}

fun pending() {
    if (this.status != LottoPublishStatus.WAITING) {
        throw IllegalStateException("Completion is only possible in the payment waiting state")
    }
    this.status = LottoPublishStatus.PENDING
}

@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select lp from LottoPublish lp where lp.id = :id")
fun findByIdWithOptimistic(@Param("id") id: Long): LottoPublish?

| 527 | lotto | 172.19.0.9:43224  | lotto | Query   |    0 | statistics | select lp1_0.id,lp1_0.issued_at,lp1_0.lotto_round_info_id,lp1_0.status from lotto_publish lp1_0 where lp1_0.id=2726 for update |
| 528 | lotto | 172.19.0.8:46378  | lotto | Query   |    0 | statistics | select lp1_0.id,lp1_0.issued_at,lp1_0.lotto_round_info_id,lp1_0.status from lotto_publish lp1_0 where lp1_0.id=2726 for update |

fun pending() {
    if (this.status != LottoPublishStatus.WAITING) {
        throw IllegalStateException("Completion is only possible in the payment waiting state")
    }
    this.status = LottoPublishStatus.PENDING
}

private fun getLottoPublish(publishId: Long, status: LottoPublishStatus): LottoPublish {
    return lottoPublishRepository.findByIdWithOptimistic(publishId, status)
        ?: throw IllegalArgumentException("Not Exist Publish")
}

SELECT *
FROM lotto_publish
WHERE id = 2726
  AND status = 'COMPLETE'
FOR UPDATE;

fun purchase(
    lottoPurchaseRequest: LottoPurchaseRequest,
    lottoPublishId: Long,
    authenticated: Authenticated
): LottoBillData = lottoPurchaseRequest.paymentKey.let { paymentKey ->
    returnExistingResultIfDone(paymentKey)?.let { return it }
    checkIdempotent(paymentKey)
  
    runCatching {
        orderValidator.checkOrderValid(lottoPurchaseRequest.toOrderDataRequest())
        lottoPublisher.pending(lottoPublishId)
        val purchase = purchaseProcessor.purchase(lottoPurchaseRequest.toPurchaseRequest())
        val lottoPublish = lottoPublisher.complete(lottoPublishId)
        val bill = lottoWriter.saveBill(purchase.getId(), lottoPublishId, authenticated.memberId)
 
        markAsDone(paymentKey, bill)
 
        LottoBillData(
            id = bill.getId()!!,
            purchase = PurchaseData.from(purchase),
            lottoPublish = LottoPublishData.from(lottoPublish)
        )
    }.getOrElse { ex ->
        handleFailure(paymentKey)
        throw ex
    }
}

private fun checkIdempotent(paymentKey: String) {
    val key = getRedisKey(paymentKey)
    val ops = redisTemplate.opsForValue()
    val currentStatus = ops.get(key)
  
    when (currentStatus) {
        "IN_PROGRESS" -> {
            throw IllegalStateException("The same request is already in progress. (Payment Key: $paymentKey)")
        }
    }
  
    val isFirstRequest = ops.setIfAbsent(key, "IN_PROGRESS", 2, TimeUnit.MINUTES)
    if (isFirstRequest == false) {
        throw IllegalStateException("The same request is already in progress. (Payment Key: $paymentKey)")
    }
}

private fun markAsDone(paymentKey: String, bill: LottoBill) {
    val ops = redisTemplate.opsForValue()
    ops.set(getRedisKey(paymentKey), "DONE:${bill.getId()}", 2, TimeUnit.MINUTES)
}