jetstream-api 0.20.3__tar.gz → 0.20.6__tar.gz

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetstream-api
-Version: 0.20.3
+Version: 0.20.6
 Summary: Python client API for iLink M.O.M. (Message Oriented Middleware)
 Author: snowjeans
 License: Boost Software License - Version 1.0 - August 17th, 2003
@@ -60,6 +60,29 @@ lz4 배치 압축을 쓰려면 `pip install "jetstream-api[lz4]"`, zstd 배치
 ## 설치 방법
 pip install jetstream-api
 
+## 0.20.6 변경 - 얼어붙은 노드를 건너뛰는 핸드셰이크 시한 · 승격 대기 (자바 v2.16.6 과 같음, 짝 엔진 7.0.1.3512 이상)
+
+> 0.20.4 · 0.20.5 는 test.pypi 시험 판으로만 냈다(회귀 BOOTFROZEN-1). 0.20.4 는 얼린 리더를 건너뛴 뒤 팔로워가 승격 전이면 생성이
+> 5초 만에 실패했고, 0.20.5 는 생성자가 승격 전에 끝나면 첫 send 가 얼린 옛 리더로 리더 링크를 열며 30초를 썼다.
+
+- **얼어붙은 노드에서 부트스트랩이 30초를 통째로 기다리지 않는다**: 멈춘(SIGSTOP) · 얼어붙은 브로커는 커널이 TCP 연결을 받아
+  주므로 접속은 되고 첫 응답이 오지 않는다. 후보를 도는 접속(프로듀서 부트스트랩 · 재접속, `ILQmgr` 주소 목록 접속 ·
+  `reconnect` · 구독 연결 · 팔로워가 준 리더 힌트로 옮겨 붙기)에서 **다른 후보가 남아 있으면** TCP 접속과 첫 `NEW_CONNECTION`
+  응답을 핸드셰이크 시한(기본 5초)만 기다리고 다음 후보로 간다. 그 시한을 넘긴 노드는 그 순회 동안 응답 없음으로 쳐서 리더
+  힌트로도 다시 가지 않는다. 응답 없음이 아닌 다른 후보가 없으면(주소 하나로 붙는 접속 등) 종전처럼 요청 · 세션 시한을 다
+  기다린다 - 바쁜 브로커를 거짓 실패시키지 않는다. PID 발급 · 메타데이터 같은 그 뒤 요청은 종전 시한이다.
+  - 설정: `ILProducerConfig.handshakeTimeoutMs(ms)`(snake `handshake_timeout_ms`), `ILQmgr.set_handshake_timeout(ms)` /
+    `setHandshakeTimeout`. 0 이하면 끈다.
+  - 팔로워 하나로 접속했는데 그 팔로워가 얼어붙은 옛 리더를 힌트로 주는 경우(장애 순간), 힌트 노드에서 짧은 시한 뒤 원래
+    주소로 돌아간다(그사이 리더가 됐으면 붙는다). `ILQmgr` 의 단일 주소 접속도 힌트로 옮겨 붙을 때 원래 주소를 뒤 후보로 둔다.
+  - **승격 대기**: 리더가 얼어 있고 팔로워가 아직 승격 전이면(팔로워가 얼린 옛 리더를 힌트로 준다) 후보가 바닥난다. 프로듀서
+    생성은 `requestTimeoutMs` 안에서 100ms → 1초로 쉬며 다시 돌아 승격이 끝나면 새 리더에 붙는다(끝내 안 되면 종전과 같은
+    시간에 마지막 거절로 실패). `ILQmgr` 후보 순회는 2회전 고정이던 것을 세션 타임아웃 안에서 1초 간격으로 되풀이한다(3회전부터는
+    리더 힌트 · 연결 계열 실패일 때만). 응답 없음 표시는 회차마다 새로 시작하고, 확정 거절(권한 · 토픽 없음 등)은 다시 돌지 않는다.
+  - **파티션 리더 링크**: 리더 표가 얼린 옛 리더를 가리키면(승격 전) 링크 열기도 핸드셰이크 시한 뒤 그 주소만 쉬고 리더 표를
+    다시 받는다 - 승격 뒤 새 리더로 간다. 같은 주소에서 잇달아 3번 넘기면 다음 한 번은 `requestTimeoutMs` 로 열고(늘 느린 리더도
+    끝내 붙게), 그렇게 오래 여는 동안에도 리더 표를 1초 간격으로 다시 받아 표가 바뀌면 배치는 기다리지 않고 새 리더로 간다.
+
 ## 0.20.3 변경 - 토픽 파티션 격리본 재주입 (자바 v2.16.3 과 같음, 짝 엔진 7.0.1.3512 이상 - 토픽 격리본은 7.0.1.3553 이상)
 
 - 격리본 토픽 파티션(엔진 7.0.1.3553 QUARTOOL-2): `reinjectQuarantine` 의 큐 인자를 선택으로 바꿨다 - 토픽 파티션 격리본은 큐를 비우고

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/README.md

@@ -10,6 +10,29 @@ lz4 배치 압축을 쓰려면 `pip install "jetstream-api[lz4]"`, zstd 배치
 ## 설치 방법
 pip install jetstream-api
 
+## 0.20.6 변경 - 얼어붙은 노드를 건너뛰는 핸드셰이크 시한 · 승격 대기 (자바 v2.16.6 과 같음, 짝 엔진 7.0.1.3512 이상)
+
+> 0.20.4 · 0.20.5 는 test.pypi 시험 판으로만 냈다(회귀 BOOTFROZEN-1). 0.20.4 는 얼린 리더를 건너뛴 뒤 팔로워가 승격 전이면 생성이
+> 5초 만에 실패했고, 0.20.5 는 생성자가 승격 전에 끝나면 첫 send 가 얼린 옛 리더로 리더 링크를 열며 30초를 썼다.
+
+- **얼어붙은 노드에서 부트스트랩이 30초를 통째로 기다리지 않는다**: 멈춘(SIGSTOP) · 얼어붙은 브로커는 커널이 TCP 연결을 받아
+  주므로 접속은 되고 첫 응답이 오지 않는다. 후보를 도는 접속(프로듀서 부트스트랩 · 재접속, `ILQmgr` 주소 목록 접속 ·
+  `reconnect` · 구독 연결 · 팔로워가 준 리더 힌트로 옮겨 붙기)에서 **다른 후보가 남아 있으면** TCP 접속과 첫 `NEW_CONNECTION`
+  응답을 핸드셰이크 시한(기본 5초)만 기다리고 다음 후보로 간다. 그 시한을 넘긴 노드는 그 순회 동안 응답 없음으로 쳐서 리더
+  힌트로도 다시 가지 않는다. 응답 없음이 아닌 다른 후보가 없으면(주소 하나로 붙는 접속 등) 종전처럼 요청 · 세션 시한을 다
+  기다린다 - 바쁜 브로커를 거짓 실패시키지 않는다. PID 발급 · 메타데이터 같은 그 뒤 요청은 종전 시한이다.
+  - 설정: `ILProducerConfig.handshakeTimeoutMs(ms)`(snake `handshake_timeout_ms`), `ILQmgr.set_handshake_timeout(ms)` /
+    `setHandshakeTimeout`. 0 이하면 끈다.
+  - 팔로워 하나로 접속했는데 그 팔로워가 얼어붙은 옛 리더를 힌트로 주는 경우(장애 순간), 힌트 노드에서 짧은 시한 뒤 원래
+    주소로 돌아간다(그사이 리더가 됐으면 붙는다). `ILQmgr` 의 단일 주소 접속도 힌트로 옮겨 붙을 때 원래 주소를 뒤 후보로 둔다.
+  - **승격 대기**: 리더가 얼어 있고 팔로워가 아직 승격 전이면(팔로워가 얼린 옛 리더를 힌트로 준다) 후보가 바닥난다. 프로듀서
+    생성은 `requestTimeoutMs` 안에서 100ms → 1초로 쉬며 다시 돌아 승격이 끝나면 새 리더에 붙는다(끝내 안 되면 종전과 같은
+    시간에 마지막 거절로 실패). `ILQmgr` 후보 순회는 2회전 고정이던 것을 세션 타임아웃 안에서 1초 간격으로 되풀이한다(3회전부터는
+    리더 힌트 · 연결 계열 실패일 때만). 응답 없음 표시는 회차마다 새로 시작하고, 확정 거절(권한 · 토픽 없음 등)은 다시 돌지 않는다.
+  - **파티션 리더 링크**: 리더 표가 얼린 옛 리더를 가리키면(승격 전) 링크 열기도 핸드셰이크 시한 뒤 그 주소만 쉬고 리더 표를
+    다시 받는다 - 승격 뒤 새 리더로 간다. 같은 주소에서 잇달아 3번 넘기면 다음 한 번은 `requestTimeoutMs` 로 열고(늘 느린 리더도
+    끝내 붙게), 그렇게 오래 여는 동안에도 리더 표를 1초 간격으로 다시 받아 표가 바뀌면 배치는 기다리지 않고 새 리더로 간다.
+
 ## 0.20.3 변경 - 토픽 파티션 격리본 재주입 (자바 v2.16.3 과 같음, 짝 엔진 7.0.1.3512 이상 - 토픽 격리본은 7.0.1.3553 이상)
 
 - 격리본 토픽 파티션(엔진 7.0.1.3553 QUARTOOL-2): `reinjectQuarantine` 의 큐 인자를 선택으로 바꿨다 - 토픽 파티션 격리본은 큐를 비우고

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/ilink/__init__.py

@@ -1,6 +1,6 @@
 """iLink - Python client API for iLink M.O.M. (Message Oriented Middleware)."""
 
-__version__ = "0.20.3"
+__version__ = "0.20.6"
 
 # --- Admin / Service ---
 from .admin import ILAdminService, ILAdminQmgr, ILLogBrowser, ILQueueBrowser

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/ilink/producer.py

@@ -27,7 +27,7 @@ from . import _codec
 from . import _groupwire as _GW
 from .common import ILC
 from .connectivity import TCPConnector, _io_lock_of
-from .exception import ILException, ILOperationException, ILTimeoutException
+from .exception import ILException, ILOperationException, ILSessionException, ILTimeoutException
 from .msg import ILMsg, ILMsgUtil, encode_property
 from .partitioner import partition_for_key
 
@@ -58,7 +58,7 @@ class ILProducerConfig:
         "acks", "lingerMs", "batchSize", "maxInFlight", "retries",
         "deliveryTimeoutMs", "requestTimeoutMs", "retryBackoffMs",
         "bufferMemory", "maxBlockMs", "maxRequestSize", "maxFrameLength", "enableIdempotence",
-        "compressionType", "compressionLz4Level", "compressionZstdLevel",
+        "compressionType", "compressionLz4Level", "compressionZstdLevel", "handshakeTimeoutMs",
     ))
 
     def __init__(self) -> None:
@@ -103,6 +103,9 @@ class ILProducerConfig:
         self._compressionLz4Level = _codec.LZ4_LEVEL_DEFAULT
         #: zstd 레벨 -131072~22. 기본 3
         self._compressionZstdLevel = _codec.ZSTD_LEVEL_DEFAULT
+        # 0.20.4: 응답 없는(얼어붙은) 노드에서 부트스트랩이 requestTimeoutMs 를 통째로 쓰지 않게
+        #: 다른 후보가 있을 때 TCP 접속 + 첫 NEW_CONNECTION 응답을 기다리는 시간(ms). 기본 5000, 0 이하면 끔
+        self._handshakeTimeoutMs = 5000
 
     def __setattr__(self, name: str, value) -> None:
         # 구버전 호환: cfg.acks = 0 / cfg.lingerMs = 5 같은 직접 대입을 내부 슬롯으로 돌린다.
@@ -292,6 +295,31 @@ class ILProducerConfig:
         """
         self._requestTimeoutMs = max(1, n); return self
 
+    def handshakeTimeoutMs(self, n: int) -> "ILProducerConfig":
+        """부트스트랩 접속 핸드셰이크 시한(밀리초) - **다른 후보가 있을 때만** 쓴다. (기본 5000 = 5초, 0.20.4)
+
+        부트스트랩(처음 접속 · 재접속)이 후보를 돌 때, 다른 후보가 남아 있으면 TCP 접속과 첫 ``NEW_CONNECTION`` 응답을 이
+        시간만 기다리고 다음 후보로 간다. 멈춘(SIGSTOP) · 얼어붙은 브로커는 커널이 TCP 연결을 받아 주므로 접속은 곧바로 되고
+        첫 응답이 오지 않는다 - 전에는 그 노드에서 :meth:`requestTimeoutMs` 를 통째로 기다렸다(장애 순간 리더 힌트가 얼어붙은
+        옛 리더를 가리킬 때 특히). 엔진은 ``NEW_CONNECTION`` 에 곧바로 답하므로 정상 노드가 이 시간을 넘길 일은 없다.
+
+        Args:
+            n (int): 시한. **0 이하면 끈다**(늘 :meth:`requestTimeoutMs`). ``requestTimeoutMs`` 보다 크면 그 값을 쓴다.
+
+        Returns:
+            ILProducerConfig: 체이닝을 위해 자기 자신.
+
+        Note:
+            짧은 시한을 넘긴 노드는 그 부트스트랩 동안 응답 없음으로 치고(리더 힌트가 가리켜도 다시 가지 않는다),
+            **응답 없음이 아닌 다른 후보가 하나도 남지 않으면** 종전처럼 ``requestTimeoutMs`` 를 다 기다린다 - 후보가 하나뿐인
+            접속이나 바쁜 브로커를 거짓 실패시키지 않는다. PID 발급 · 메타데이터 같은 그 뒤 요청은 늘 ``requestTimeoutMs`` 다.
+
+            0.20.6: **파티션 리더 링크**를 열 때도 쓴다 - 리더 표가 얼어붙은 옛 리더를 가리키면(승격 전) 이 시간 뒤 그 주소만 쉬고
+            리더 표를 다시 받아 승격 뒤 새 리더로 간다. 같은 주소에서 잇달아 3번 넘기면 다음 한 번은 ``requestTimeoutMs`` 로 열고,
+            그동안에도 리더 표를 주기적으로 다시 받는다(늘 느린 리더도 끝내 붙는다).
+        """
+        self._handshakeTimeoutMs = int(n); return self
+
     def retryBackoffMs(self, n: int) -> "ILProducerConfig":
         """재시도 사이에 쉬는 시간(밀리초). (기본 100)
 
@@ -515,6 +543,10 @@ class ILProducerConfig:
         """:meth:`requestTimeoutMs` 의 snake 별칭."""
         return self.requestTimeoutMs(n)
 
+    def handshake_timeout_ms(self, n: int) -> "ILProducerConfig":
+        """:meth:`handshakeTimeoutMs` 의 snake 별칭."""
+        return self.handshakeTimeoutMs(n)
+
     def retry_backoff_ms(self, n: int) -> "ILProducerConfig":
         """:meth:`retryBackoffMs` 의 snake 별칭."""
         return self.retryBackoffMs(n)
@@ -615,6 +647,14 @@ class ILProducerConfig:
         """
         return self._requestTimeoutMs
 
+    def get_handshake_timeout_ms(self) -> int:
+        """부트스트랩 접속 핸드셰이크 시한(밀리초). 기본 5000. 0 이하면 꺼짐.
+
+        Returns:
+            int: 시한(밀리초).
+        """
+        return self._handshakeTimeoutMs
+
     def get_retry_backoff_ms(self) -> int:
         """재시도 간 대기(밀리초). 기본 100.
 
@@ -698,6 +738,7 @@ class ILProducerConfig:
     getDeliveryTimeoutMs = get_delivery_timeout_ms
     getRequestTimeoutMs = get_request_timeout_ms
     getRetryBackoffMs = get_retry_backoff_ms
+    getHandshakeTimeoutMs = get_handshake_timeout_ms
     getBufferMemory = get_buffer_memory
     getMaxBlockMs = get_max_block_ms
     getMaxRequestSize = get_max_request_size
@@ -1623,8 +1664,14 @@ class ILTopicProducer:
         self._pmeta_retry_at = 0.0
         #: 리더 주소 -> 다시 열어 볼 시각(열기에 실패한 뒤 백오프)
         self._open_retry_at: dict = {}
+        #: 0.20.5: 리더 링크 주소 -> 짧은 핸드셰이크 시한을 잇달아 넘긴 횟수. 3번이면 다음 한 번은 requestTimeoutMs 로 연다
+        self._hs_strikes: dict = {}
         #: 여는 스레드가 여는 중인 리더 주소 / 끝낸 결과 (주소, 커넥터, (파티션 수, epoch, 세그먼트), 예외)
         self._opening: set = set()
+        #: 0.20.5: 여는 중인 리더 링크 주소 -> 열기 시작 시각. 핸드셰이크 시한보다 오래 걸리면(얼어붙은 리더 · 종전 시한 회차)
+        #:   리더 표를 주기적으로 다시 받는다 - 표가 새 리더를 가리키면 배치는 열기가 끝나기를 기다리지 않고 그리로 간다
+        self._opening_since: dict = {}
+        self._open_refresh_at = 0.0
         self._opened: collections.deque = collections.deque()
         self._corr = 0
         self._next_seq: list[int] = []
@@ -1650,7 +1697,7 @@ class ILTopicProducer:
         self._sel.register(self._wake_r, selectors.EVENT_READ, "wake")
         try:
             # 첫 연결은 동기로 한다 - 주소 / 핸드셰이크 / 토픽 오류를 생성 시점에 드러낸다
-            self._bootstrap()
+            self._bootstrap(wait=True)
         except Exception:
             self._shutdown_quietly()
             raise
@@ -1659,31 +1706,78 @@ class ILTopicProducer:
         self._thread.start()
 
     # ── 부트스트랩(블로킹): 연결 + 핸드셰이크 + (멱등) PID + 토픽 메타데이터 -> 논블로킹 등록 ──
-    def _bootstrap(self) -> None:
-        """후보를 순회하며 접속한다. 리더 힌트를 받으면 그 주소를 맨 앞으로 올려 곧바로 다시 시도한다."""
+    def _bootstrap(self, wait: bool = False) -> None:
+        """후보를 순회하며 접속한다(:meth:`_bootstrap_pass`).
+
+        0.20.4: ``wait`` 면(생성자의 첫 연결) 후보가 바닥나도 requestTimeoutMs 안에서 100ms -> 1s 로 쉬며 다시 돈다 - 리더가
+        얼어 있고 팔로워가 아직 승격 전이면(팔로워가 얼어붙은 옛 리더를 힌트로 준다) 승격이 끝날 때 새 리더에 붙는다. 다시
+        도는 것은 리더 힌트 · 연결 계열 실패뿐이다(토픽 없음 같은 확정 거절은 곧바로 올린다). 응답 없음 표시는 회차마다 새로
+        시작한다. I/O 스레드의 재접속은 그 루프가 백오프하며 전달 시한까지 다시 돌므로 한 회차만 한다."""
+        if not wait:
+            self._bootstrap_pass()
+            return
+        deadline = time.monotonic() + self.config.get_request_timeout_ms() / 1000.0
+        pause = 0.1
+        while True:
+            try:
+                self._bootstrap_pass()
+                return
+            except Exception as exc:            # noqa: BLE001
+                retryable = (_extract_leader_hint(exc) is not None
+                             or isinstance(exc, (ILSessionException, OSError))
+                             or getattr(exc, "_il_handshake", False))
+                if not retryable or time.monotonic() + pause >= deadline:
+                    raise
+            time.sleep(pause)
+            pause = min(pause * 2, 1.0)
+
+    def _bootstrap_pass(self) -> None:
+        """후보를 한 바퀴 돈다. 리더 힌트를 받으면 그 주소를 맨 앞으로 올려 곧바로 다시 시도한다.
+
+        0.20.4: 다른 후보가 남아 있으면 TCP 접속과 첫 NEW_CONNECTION 응답을 handshakeTimeoutMs 만 기다린다. 그 시한을 넘긴
+        노드는 이번 부트스트랩 동안 응답 없음(silent)으로 치고 리더 힌트로도 다시 올리지 않는다. 응답 없음이 아닌 다른
+        후보가 없으면 requestTimeoutMs 를 다 기다린다(후보 하나 · 바쁜 브로커를 거짓 실패시키지 않는다)."""
         last: Exception | None = None
-        for _ in range(len(self._candidates) + 1):
+        full = self.config.get_request_timeout_ms()
+        hs = self.config.get_handshake_timeout_ms()
+        silent: set = set()
+        n = 0
+        while n < len(self._candidates) + 1:
+            n += 1
             addr = self._candidates[self._cand_idx % len(self._candidates)]
             colon = addr.rfind(":")
+            short = 0 < hs < full and any(c != addr and c not in silent for c in self._candidates)
             try:
-                self._bootstrap_one(addr[:colon], int(addr[colon + 1:]))
+                self._bootstrap_one(addr[:colon], int(addr[colon + 1:]), hs if short else full)
                 return
             except Exception as exc:            # noqa: BLE001 - 후보를 계속 돈다
                 last = exc
+                if short and getattr(exc, "_il_handshake", False):
+                    silent.add(addr)
                 hint = _extract_leader_hint(exc)
-                if hint and self._promote(hint):
+                if hint and hint not in silent and self._promote(hint):
                     continue                    # 힌트부터 재시도
                 self._cand_idx = (self._cand_idx + 1) % len(self._candidates)
         raise last if last is not None else ILOperationException("no reachable node")
 
-    def _bootstrap_one(self, host: str, port: int) -> None:
+    def _bootstrap_one(self, host: str, port: int, handshake_ms: int = 0) -> None:
         conn = TCPConnector()
         conn.max_frame_length = self.config.get_max_frame_length()
-        conn.connect(host, port, self.config.get_request_timeout_ms())
+        hs = handshake_ms if handshake_ms > 0 else self.config.get_request_timeout_ms()
         try:
+            conn.connect(host, port, hs)
             # 0.18.0: 능력 선언. ☠ arg1("1")은 자동커밋 플래그라 그대로 둔다.
             rep = self._request(conn, ILC.MIMQ_NEW_CONNECTION, "1", self.clientName, "USR",
-                                ext=ILC.client_caps_extension())
+                                ext=ILC.client_caps_extension(), timeout_ms=hs)
+        except ILSessionException as exc:
+            # 0.20.4: 핸드셰이크(접속 + 첫 응답)에서 닿지 않았다 - _bootstrap 이 이 노드를 응답 없음으로 친다
+            conn.shutdown()
+            exc._il_handshake = True
+            raise
+        except Exception:
+            conn.shutdown()
+            raise
+        try:
             if rep is None or rep.getCode() != ILC.MIMQ_SUCCESSFUL_CONNECTION:
                 raise ILOperationException((rep.getArg2() if rep is not None else "")
                                            or "MIMQE_INVALID_MSG_FORMAT (connection)")
@@ -1742,9 +1836,21 @@ class ILTopicProducer:
             colon = addr.rfind(":")
             conn = TCPConnector()
             conn.max_frame_length = self.config.get_max_frame_length()
-            conn.connect(addr[:colon], int(addr[colon + 1:]), self.config.get_request_timeout_ms())
-            rep = self._request(conn, ILC.MIMQ_NEW_CONNECTION, "1", self.clientName, "USR",
-                                ext=ILC.client_caps_extension(True))
+            # 0.20.5: 리더 표가 얼어붙은 옛 리더를 가리키면(승격 전) 접속 + 첫 응답을 handshakeTimeoutMs 만 기다리고 그 주소만
+            #   백오프한다 - 리더 표를 다시 받아 승격 뒤 새 리더로 간다. 같은 주소에서 잇달아 3번 넘기면 다음 한 번은
+            #   requestTimeoutMs 로 연다(늘 느린 리더를 끝내 못 붙는 일이 없게). 여는 스레드라 I/O 스레드는 멈추지 않는다
+            full = self.config.get_request_timeout_ms()
+            hs = self.config.get_handshake_timeout_ms()
+            short = 0 < hs < full and self._hs_strikes.get(addr, 0) < 3
+            tmo = hs if short else full
+            try:
+                conn.connect(addr[:colon], int(addr[colon + 1:]), tmo)
+                rep = self._request(conn, ILC.MIMQ_NEW_CONNECTION, "1", self.clientName, "USR",
+                                    ext=ILC.client_caps_extension(True), timeout_ms=tmo)
+            except ILSessionException as hx:
+                if short:
+                    hx._il_handshake = True
+                raise
             if rep is None or rep.getCode() != ILC.MIMQ_SUCCESSFUL_CONNECTION:
                 raise ILOperationException((rep.getArg2() if rep is not None else "")
                                            or "MIMQE_INVALID_MSG_FORMAT (connection)")
@@ -1773,7 +1879,12 @@ class ILTopicProducer:
         while self._opened:
             addr, conn, meta, exc = self._opened.popleft()
             self._opening.discard(addr)
+            self._opening_since.pop(addr, None)
             if exc is not None:
+                if getattr(exc, "_il_handshake", False):
+                    self._hs_strikes[addr] = self._hs_strikes.get(addr, 0) + 1
+                else:
+                    self._hs_strikes.pop(addr, None)    # 종전 시한으로 연 회차(또는 다른 실패) 뒤에는 다시 짧은 시한부터
                 self._open_retry_at[addr] = time.monotonic() + self._backoff
                 self._pmeta_stale = True
                 answer = "cannot reach partition leader %s: %s" % (addr, str(exc) or type(exc).__name__)
@@ -1795,15 +1906,16 @@ class ILTopicProducer:
                 self._open_retry_at[addr] = time.monotonic() + self._backoff
                 continue
             self._open_retry_at.pop(addr, None)
+            self._hs_strikes.pop(addr, None)
             with self._cv:
                 self._by_addr[addr] = link
                 self._links = self._links + (link,)
 
-    def _request(self, conn: TCPConnector, code: int, *args: str, ext: bytes = None):
+    def _request(self, conn: TCPConnector, code: int, *args: str, ext: bytes = None, timeout_ms: int = 0):
         with _io_lock_of(conn):         # 0.7.3: 부트스트랩 전용 연결이지만 요청-응답 짝 규칙은 같게
             conn.send(ILMsgUtil.create_request_msg_with_ext(code, ext, *args)
                       if ext is not None else ILMsgUtil.create_request_msg(code, *args))
-            res = conn.recv(self.config.get_request_timeout_ms())
+            res = conn.recv(timeout_ms if timeout_ms > 0 else self.config.get_request_timeout_ms())
         if res.getType() == ILC.MIMQ_REPORT_MESSAGE:
             return res.getReportMsg()
         return None
@@ -2374,13 +2486,27 @@ class ILTopicProducer:
                     addr = self._leaders[p]
                     if addr is not None and addr not in self._by_addr and addr not in want:
                         want.append(addr)
+        hs_s = self._open_stall_s()
         for addr in want:
-            if addr in self._opening or now < self._open_retry_at.get(addr, 0.0):
+            if addr in self._opening:
+                # 0.20.5: 열기가 핸드셰이크 시한을 넘겼다 - 리더 표를 다시 받는다(승격되면 새 리더로 간다)
+                if now - self._opening_since.get(addr, now) >= hs_s and now >= self._open_refresh_at:
+                    self._pmeta_stale = True
+                    self._open_refresh_at = now + max(self._backoff, 1.0)
+                continue
+            if now < self._open_retry_at.get(addr, 0.0):
                 continue
             self._opening.add(addr)
+            self._opening_since[addr] = now
             threading.Thread(target=self._open_link_bg, args=(addr,), daemon=True,
                              name="jetstream-producer-link-%d" % next(_THREAD_SEQ)).start()
 
+    def _open_stall_s(self) -> float:
+        """리더 링크 열기가 이보다 오래 걸리면 리더 표를 다시 받는다(초) - 핸드셰이크 시한, 꺼져 있으면 requestTimeoutMs."""
+        hs = self.config.get_handshake_timeout_ms()
+        full = self.config.get_request_timeout_ms()
+        return (hs if 0 < hs < full else full) / 1000.0
+
     def _compute_wait(self, now: float) -> float:
         wait = _IO_WAIT_CAP
         links = self._links
@@ -2408,6 +2534,10 @@ class ILTopicProducer:
                     # 리더 링크를 아직 못 열었다 - 여는 중이면 여는 스레드가 깨우고, 아니면 다시 열어 볼 시각에 깬다
                     if self._leaders[p] not in self._opening:
                         wait = min(wait, self._open_retry_at.get(self._leaders[p], 0.0) - now)
+                    else:
+                        # 0.20.5: 오래 걸리는 열기 동안 리더 표를 다시 받을 시각에 깬다
+                        since = self._opening_since.get(self._leaders[p], now)
+                        wait = min(wait, max(since + self._open_stall_s(), self._open_refresh_at) - now)
                     continue
                 # 그 링크가 epoch 를 다시 받는 중이거나 가득 찼거나, 다른 링크에 이 파티션이 실려 있다 - 응답이 깨운다
                 if link.meta_stale or link.retire or (self._acks != 0 and len(link.inflight) >= self._max_in_flight):

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/ilink/qmgr.py

@@ -200,6 +200,8 @@ class ILQmgr:
         self._connGen = 0
         # 0.7.3 소비 v5: 구독 전용 세션이면 True - 접속 핸드셰이크가 끝날 때마다 연결을 요청 태그 계층으로 바꾼다
         self._subTagged = False
+        #: 0.20.4: 다른 후보가 있을 때 TCP 접속 + 첫 NEW_CONNECTION 응답을 기다리는 시간(ms). 0 이하면 끔
+        self._handshakeTimeoutMS = 5000
         self._capPlead = False      # 0.19.0: True 면 접속 CAP 에 plead=1(팔로워도 받아 달라) - 구독 세션만
         # 0.20.0: True 면 접속 CAP 에 qlead=1(큐마다 묶음 리더를 찾아 간다) - 앱의 큐 세션과 큐 링크. 구독 세션은 끈다
         self._capQlead = True
@@ -371,6 +373,7 @@ class ILQmgr:
         clientName: str | None = None,
         isAutoCommit: bool | None = None,
         _allow_redirect: bool = True,
+        _handshake_ms: int = 0,
     ) -> None:
         """큐 관리자에 접속해 세션을 연다.
 
@@ -478,20 +481,32 @@ class ILQmgr:
         try:
             self.host = host
             self.port = port
-            self.service.connect(host, port)
-            if not client_name:
-                # 0.11.0 K10: inspect.stack()[-1] 과 같은 값(가장 바깥 프레임의 모듈 이름). 프레임만 거슬러 올라가므로 소스 줄을
-                #   읽지 않는다(전에는 첫 접속에 약 1.6 ms)
-                client_name = caller_module_name()
-            self.clientName = client_name
-            conn_mode = ILC.MIMQ_SESSION_TRANSACTED
-            if auto_commit:
-                conn_mode = ILC.MIMQ_AUTO_ACKNOWLEDGE
-            # 0.18.0: 능력 선언. ☠ arg1(conn_mode)은 자동커밋 플래그라 건드리지 않는다.
-            _caps = ILC.client_caps_extension(getattr(self, "_capPlead", False), getattr(self, "_capQlead", False))
-            _cargs = ((ILC.MIMQ_NEW_CONNECTION,) + ((_caps,) if _caps else ())
-                      + (str(conn_mode), client_name, "USR"))
-            conn_res_msg = self.service.request(*_cargs)
+            # 0.20.4: 후보 순회(_connect_any)가 다른 후보를 남겨 두고 부르면 접속 + 첫 응답만 짧은 시한으로 기다린다
+            _saved_tmo = self.service.sessionTimeoutMS
+            _short = 0 < _handshake_ms < _saved_tmo
+            if _short:
+                self.service.sessionTimeoutMS = _handshake_ms
+            try:
+                self.service.connect(host, port)
+                if not client_name:
+                    # 0.11.0 K10: inspect.stack()[-1] 과 같은 값(가장 바깥 프레임의 모듈 이름). 프레임만 거슬러 올라가므로 소스
+                    #   줄을 읽지 않는다(전에는 첫 접속에 약 1.6 ms)
+                    client_name = caller_module_name()
+                self.clientName = client_name
+                conn_mode = ILC.MIMQ_SESSION_TRANSACTED
+                if auto_commit:
+                    conn_mode = ILC.MIMQ_AUTO_ACKNOWLEDGE
+                # 0.18.0: 능력 선언. ☠ arg1(conn_mode)은 자동커밋 플래그라 건드리지 않는다.
+                _caps = ILC.client_caps_extension(getattr(self, "_capPlead", False), getattr(self, "_capQlead", False))
+                _cargs = ((ILC.MIMQ_NEW_CONNECTION,) + ((_caps,) if _caps else ())
+                          + (str(conn_mode), client_name, "USR"))
+                conn_res_msg = self.service.request(*_cargs)
+            except ILSessionException as _hx:
+                if _short:
+                    _hx._il_handshake = True        # _connect_any 가 이 노드를 응답 없음으로 친다
+                raise
+            finally:
+                self.service.sessionTimeoutMS = _saved_tmo
             if conn_res_msg is None:
                 raise ILOperationException("MIMQE_INTERNAL_ERROR")
             if conn_res_msg.getCode() != ILC.MIMQ_SUCCESSFUL_CONNECTION:
@@ -563,18 +578,13 @@ class ILQmgr:
             if _allow_redirect:
                 hint = self._remember_leader_hint(exc)
                 if hint:
-                    colon = hint.rfind(":")
                     try:
                         self.service.shutdown()
                     except Exception:
                         pass
-                    self.connect(
-                        hint[:colon],
-                        int(hint[colon + 1:]),
-                        client_name,
-                        auto_commit,
-                        _allow_redirect=False,
-                    )
+                    # 0.20.4: 힌트 노드로 옮겨 붙되 원래 주소를 뒤 후보로 둔다 - 힌트가 얼어붙은 옛 리더면 짧은 시한 뒤
+                    #   원래 주소(그사이 리더가 됐을 수 있다)로 돌아간다. 전에는 힌트 노드에서 세션 타임아웃을 통째로 기다렸다
+                    self._connect_any([hint, "%s:%s" % (host, port)], client_name, auto_commit)
                     return
                 # 힌트를 줄 상대조차 없으면(노드가 죽어 있음) 파일에 남겨 둔
                 # 후보로 한 번 더 돈다. 경로를 지정했을 때만 동작한다.
@@ -803,6 +813,38 @@ class ILQmgr:
         """:meth:`is_connected` 의 camelCase 별칭."""
         return self.is_connected()
 
+    def set_handshake_timeout(self, timeout_ms: int) -> None:
+        """여러 후보로 접속할 때 **응답 없는(얼어붙은) 노드**를 건너뛰는 핸드셰이크 시한(밀리초)을 정한다(0.20.4). 기본 5000.
+
+        주소 목록 접속 · :meth:`reconnect` · 구독 연결 · 리더 힌트 이동처럼 후보를 돌 때, 다른 후보가 남아 있으면 TCP 접속과 첫
+        ``NEW_CONNECTION`` 응답을 이 시간만 기다리고 다음 후보로 간다. 멈춘(SIGSTOP) · 얼어붙은 노드는 커널이 TCP 연결을 받아
+        주므로 접속은 되고 응답이 오지 않는다 - 전에는 세션 타임아웃을 통째로 기다렸다.
+
+        Args:
+            timeout_ms (int): 시한(밀리초). **0 이하면 끈다**(늘 세션 타임아웃). 세션 타임아웃보다 크면 세션 타임아웃을 쓴다.
+
+        Note:
+            짧은 시한을 넘긴 노드는 그 순회 동안 응답 없음으로 친다. **응답 없음이 아닌 다른 후보가 없으면** 종전처럼 세션
+            타임아웃을 다 기다린다 - 주소 하나로 붙는 접속이나 바쁜 엔진을 거짓 실패시키지 않는다.
+        """
+        self._handshakeTimeoutMS = int(timeout_ms)
+
+    def setHandshakeTimeout(self, timeoutMS: int) -> None:
+        """:meth:`set_handshake_timeout` 의 camelCase 별칭."""
+        self.set_handshake_timeout(timeoutMS)
+
+    def get_handshake_timeout(self) -> int:
+        """핸드셰이크 시한(밀리초). 기본 5000. 0 이하면 꺼짐.
+
+        Returns:
+            int: 시한(밀리초).
+        """
+        return self._handshakeTimeoutMS
+
+    def getHandshakeTimeout(self) -> int:
+        """:meth:`get_handshake_timeout` 의 camelCase 별칭."""
+        return self.get_handshake_timeout()
+
     def set_session_timeout(self, timeout_ms: int) -> None:
         """응답 패킷을 기다리는 시간을 정한다.
 
@@ -1121,8 +1163,17 @@ class ILQmgr:
     def _connect_any(self, candidates: list[str], client_name: str, auto_commit: bool) -> None:
         # 후보를 순회하며 접속한다. 리더 힌트를 받으면 그 주소를 맨 앞으로 올려 재시도.
         # 최대 2회전(그 사이 승격이 끝날 수 있으므로 1초 쉬고 한 번 더).
+        # 0.20.4: 다른 후보가 남아 있으면 접속 + 첫 NEW_CONNECTION 응답을 _handshakeTimeoutMS 만 기다린다. 그 시한을 넘긴
+        #   노드는 이번 순회 동안 응답 없음(silent)으로 치고 리더 힌트로도 다시 올리지 않는다. 응답 없음이 아닌 다른 후보가
+        #   없으면 세션 타임아웃을 다 기다린다(후보 하나 · 바쁜 엔진을 거짓 실패시키지 않는다)
+        # 0.20.4: 2회전 고정이던 것을 세션 타임아웃 안에서 되풀이한다(최소 2회전, 사이 1초) - 리더가 얼어 있고 팔로워가 아직
+        #   승격 전이면 승격이 끝날 때 새 리더에 붙는다. 응답 없음 표시는 회전마다 새로 시작한다
         last_error = None
-        for _round in range(2):
+        hs = self._handshakeTimeoutMS
+        deadline = time.monotonic() + max(self.service.sessionTimeoutMS, 0) / 1000.0
+        _round = 0
+        while True:
+            silent: set = set()
             i = 0
             while i < len(candidates):
                 addr = candidates[i]
@@ -1134,14 +1185,20 @@ class ILQmgr:
                     port = int(addr[colon + 1:])
                 except Exception:
                     i += 1; continue
+                short = hs > 0 and any(c != addr and c not in silent for c in candidates)
                 try:
-                    self.connect(host, port, client_name, auto_commit, _allow_redirect=False)
+                    self.connect(host, port, client_name, auto_commit, _allow_redirect=False,
+                                 _handshake_ms=hs if short else 0)
                     return
                 except Exception as exc:
                     last_error = exc
                     try: self.service.shutdown()
                     except Exception: pass
+                    if short and any(getattr(t, "_il_handshake", False) for t in (exc, exc.__cause__)):
+                        silent.add(addr)
                     hint = self._remember_leader_hint(exc)
+                    if hint and hint in silent:
+                        hint = None
                     if hint and hint not in candidates:
                         candidates.insert(0, hint); i = 0; continue
                     if hint:
@@ -1149,6 +1206,15 @@ class ILQmgr:
                         if idx > 0:
                             candidates.pop(idx); candidates.insert(0, hint); i = 0; continue
                     i += 1
+            _round += 1
+            if _round >= 2:
+                # 3회전부터는 리더 힌트 · 연결 계열 실패일 때만(권한 거절 같은 확정 실패는 종전대로 2회전)
+                retryable = (last_error is not None
+                             and (self._extract_leader_hint(last_error) is not None
+                                  or isinstance(last_error, ILSessionException)
+                                  or isinstance(getattr(last_error, "__cause__", None), ILSessionException)))
+                if not retryable or time.monotonic() + 1.0 >= deadline:
+                    break
             time.sleep(1.0)
         if last_error is not None:
             raise last_error

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/jetstream_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetstream-api
-Version: 0.20.3
+Version: 0.20.6
 Summary: Python client API for iLink M.O.M. (Message Oriented Middleware)
 Author: snowjeans
 License: Boost Software License - Version 1.0 - August 17th, 2003
@@ -60,6 +60,29 @@ lz4 배치 압축을 쓰려면 `pip install "jetstream-api[lz4]"`, zstd 배치
 ## 설치 방법
 pip install jetstream-api
 
+## 0.20.6 변경 - 얼어붙은 노드를 건너뛰는 핸드셰이크 시한 · 승격 대기 (자바 v2.16.6 과 같음, 짝 엔진 7.0.1.3512 이상)
+
+> 0.20.4 · 0.20.5 는 test.pypi 시험 판으로만 냈다(회귀 BOOTFROZEN-1). 0.20.4 는 얼린 리더를 건너뛴 뒤 팔로워가 승격 전이면 생성이
+> 5초 만에 실패했고, 0.20.5 는 생성자가 승격 전에 끝나면 첫 send 가 얼린 옛 리더로 리더 링크를 열며 30초를 썼다.
+
+- **얼어붙은 노드에서 부트스트랩이 30초를 통째로 기다리지 않는다**: 멈춘(SIGSTOP) · 얼어붙은 브로커는 커널이 TCP 연결을 받아
+  주므로 접속은 되고 첫 응답이 오지 않는다. 후보를 도는 접속(프로듀서 부트스트랩 · 재접속, `ILQmgr` 주소 목록 접속 ·
+  `reconnect` · 구독 연결 · 팔로워가 준 리더 힌트로 옮겨 붙기)에서 **다른 후보가 남아 있으면** TCP 접속과 첫 `NEW_CONNECTION`
+  응답을 핸드셰이크 시한(기본 5초)만 기다리고 다음 후보로 간다. 그 시한을 넘긴 노드는 그 순회 동안 응답 없음으로 쳐서 리더
+  힌트로도 다시 가지 않는다. 응답 없음이 아닌 다른 후보가 없으면(주소 하나로 붙는 접속 등) 종전처럼 요청 · 세션 시한을 다
+  기다린다 - 바쁜 브로커를 거짓 실패시키지 않는다. PID 발급 · 메타데이터 같은 그 뒤 요청은 종전 시한이다.
+  - 설정: `ILProducerConfig.handshakeTimeoutMs(ms)`(snake `handshake_timeout_ms`), `ILQmgr.set_handshake_timeout(ms)` /
+    `setHandshakeTimeout`. 0 이하면 끈다.
+  - 팔로워 하나로 접속했는데 그 팔로워가 얼어붙은 옛 리더를 힌트로 주는 경우(장애 순간), 힌트 노드에서 짧은 시한 뒤 원래
+    주소로 돌아간다(그사이 리더가 됐으면 붙는다). `ILQmgr` 의 단일 주소 접속도 힌트로 옮겨 붙을 때 원래 주소를 뒤 후보로 둔다.
+  - **승격 대기**: 리더가 얼어 있고 팔로워가 아직 승격 전이면(팔로워가 얼린 옛 리더를 힌트로 준다) 후보가 바닥난다. 프로듀서
+    생성은 `requestTimeoutMs` 안에서 100ms → 1초로 쉬며 다시 돌아 승격이 끝나면 새 리더에 붙는다(끝내 안 되면 종전과 같은
+    시간에 마지막 거절로 실패). `ILQmgr` 후보 순회는 2회전 고정이던 것을 세션 타임아웃 안에서 1초 간격으로 되풀이한다(3회전부터는
+    리더 힌트 · 연결 계열 실패일 때만). 응답 없음 표시는 회차마다 새로 시작하고, 확정 거절(권한 · 토픽 없음 등)은 다시 돌지 않는다.
+  - **파티션 리더 링크**: 리더 표가 얼린 옛 리더를 가리키면(승격 전) 링크 열기도 핸드셰이크 시한 뒤 그 주소만 쉬고 리더 표를
+    다시 받는다 - 승격 뒤 새 리더로 간다. 같은 주소에서 잇달아 3번 넘기면 다음 한 번은 `requestTimeoutMs` 로 열고(늘 느린 리더도
+    끝내 붙게), 그렇게 오래 여는 동안에도 리더 표를 1초 간격으로 다시 받아 표가 바뀌면 배치는 기다리지 않고 새 리더로 간다.
+
 ## 0.20.3 변경 - 토픽 파티션 격리본 재주입 (자바 v2.16.3 과 같음, 짝 엔진 7.0.1.3512 이상 - 토픽 격리본은 7.0.1.3553 이상)
 
 - 격리본 토픽 파티션(엔진 7.0.1.3553 QUARTOOL-2): `reinjectQuarantine` 의 큐 인자를 선택으로 바꿨다 - 토픽 파티션 격리본은 큐를 비우고

{jetstream_api-0.20.3 → jetstream_api-0.20.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jetstream-api"
-version = "0.20.3"
+version = "0.20.6"
 description = "Python client API for iLink M.O.M. (Message Oriented Middleware)"
 authors = [{name = "snowjeans"}]
 readme = "README.md"