KTOR Server 에서 delay

- 학습 관련 질문을 남겨주세요. 질문을 상세히 작성하면 더 좋습니다.
- 서로 예의를 지키며 존중하는 문화를 만들어가요.
- 잠깐! 인프런 서비스 운영 관련 문의는 1:1 문의하기를 이용해주세요.

안녕하세요, coroutine 강의를 듣고 ktor server 공부를 하는 중에 delay 관련 질의가 생겨 글 남깁니다.

delay 의 경우 coroutine 이 스레드를 양보하고, 일정 시간 후에 다시 스레드가 비어있으면 점유하는 형식으로 진행될텐데, 아래와 같은 경우 delay 이후 코드가 실행되지 않습니다.

사용자 → KTOR Server → suspend function call → loop { logic → 너무 많은 동작을 제한하기위한 delay }

ktor 는 기본적으로 요청이 IO Dispatcher 를 사용하는 것 같은데, coroutine 에서 delay 이후 기능이 동작하지 않는 것에 대한 이유가 있을까요..? (강의랑 무관한 내용이라 죄송합니다 ㅠ.ㅠ)

/* Routing.kt */
fun Application.configureRouting(searcher: BaseSearcher) {
    routing {

        post("/search") {
            val params = call.receive<Map<String, String>>()

            searcher.logging("Received POST request with params: $params")
            val result: List<BaseDTO> = searcher.search(params)
            searcher.logging("POST Result: $result")
            call.respond(HttpStatusCode.OK, mapOf("result" to result))
        }

        get("/") {
            call.respondText("Hello World!")
        }
    }
}

/* Searcher.kt */


    /**
     *  함수 이름 : search
     *  내용 설명 : 입력된 map<string, string> param 을 바탕으로 요청 전송 및 응답 반환
     */
    override suspend fun search(searchParam: Map<String, String>): List<SimpleSearchLandResultDTO> {
        // 별도의 Job 으로 분리해서 오류시 상위 전파 제한
        return HttpClient(CIO).use { client ->
            val parseResultLst: MutableList<SimpleSearchLandResultDTO> = mutableListOf()

            try {
                val initRequestResultDto: SimpleSearchResultDTO =
                    sendFormedRequest(client, SearcherConst.URL_MAIN_PAGE, false)

                // 기본 페이지 요청이 성공했을 때 다음 요청을 진행
                if (initRequestResultDto.isSuccess) {
                    val mutableSearchParam = searchParam.toMutableMap()

                    delay(300)

                    while (true) {

                        val eachPageSearchResultDto: SimpleSearchResultDTO =
                            sendFormedRequest(client, makeGetUrl(mutableSearchParam), true)

                        // 실패한 경우 종료
                        if (!eachPageSearchResultDto.isSuccess) {
                            logging("[search] 조회 중 오류가 발생하였습니다.")
                            break
                        }
                        // 결과가 빈 경우도 종료
                        else if (eachPageSearchResultDto.landSearchResultLst.isEmpty()) {
                            break
                        }

                        // 결과가 있는 경우엔 전부 더해줌
                        parseResultLst.addAll(eachPageSearchResultDto.landSearchResultLst)

                        logging("[search] result(${eachPageSearchResultDto.landSearchResultLst[0].currentPage} : ${eachPageSearchResultDto.landSearchResultLst}")

                        // 마지막 페이지인 경우 종료
                        if (eachPageSearchResultDto.landSearchResultLst[0].currentPage ==
                            eachPageSearchResultDto.landSearchResultLst[0].maxPage
                        ) {
                            break
                        } else {
                            // 다음 페이지 수집 진행
                            mutableSearchParam["currentPage"] =
                                (eachPageSearchResultDto.landSearchResultLst[0].currentPage + 1).toString()

                            delay(300)
                        }
                    }
                }
            } catch (e: Exception) {
                logging("[search] search 함수 중 오류가 발생하였습니다. param: $searchParam, exception: $e")
            }

            logging("[search] Result : $parseResultLst")

            // parseResultLst 반환
            parseResultLst
        }
    }

private suspend fun sendFormedRequest(client: HttpClient, url: String, isResultNeed: Boolean): SimpleSearchResultDTO {
        return try {

            val response = client.get(url) {
                headers {
                    append(HttpHeaders.Cookie, cookie.toCookieString())
                    append(HttpHeaders.Accept, SearcherConst.DEFAULT_HTTP_ACCEPT)
                    append(HttpHeaders.AcceptEncoding, SearcherConst.DEFAULT_HTTP_ACCEPT_ENCODING)
                    append(HttpHeaders.Connection, SearcherConst.DEFAULT_HTTP_CONNECTION)
                    append(HttpHeaders.AcceptLanguage, SearcherConst.DEFAULT_HTTP_ACCEPT_LANGUAGE)
                    append(HttpHeaders.UserAgent, SearcherConst.DEFAULT_HTTP_USER_AGENT)
                }
            }

            cookie.putAll(response.headers[HttpHeaders.SetCookie]?.split(";")?.map { it.split("=") }?.
            filter { it.size == 2 }?.filter { it[1] != "/" && it[1].isNotEmpty() }?.associate { it[0] to it[1] } ?: mapOf())

            if (response.status != HttpStatusCode.OK) {
                SimpleSearchResultDTO(false)
            } else {
                SimpleSearchResultDTO(true, if(isResultNeed) parseData(response.bodyAsText()) else mutableListOf())
            }
        } catch(e: Exception) {
            logging("[sendFormedRequest] Error : $e", Level.ERROR)
            SimpleSearchResultDTO(false)
        }
    }