HTTPX PoolTimeout ဟာ ပရောက်စီချိတ်ဆက်ချိန်ကုန်တာ မဟုတ်ပါ

PoolTimeout ဆိုတာ HTTPX က သတ်မှတ်ထားတဲ့ စောင့်ဆိုင်းချိန်အတွင်း pool ကနေ ချိတ်ဆက်မှုမရခဲ့တာပါ။ ပရောက်စီဆီ TCP ချိတ်ဆက်မှုအသစ် အချိန်ကုန်သွားတဲ့ သက်သေ မဟုတ်ပါ။ ဒုတိယတောင်းဆိုမှုက သင့် process ထဲမှာပဲ စောင့်နေသေးတာ ဖြစ်နိုင်ပါတယ်။

client က ချိတ်ဆက်မှုတစ်ခုသာ ခွင့်ပြုပြီး ပထမ streaming response ကို ဖွင့်ထားရင် ဒီအခြေအနေကို အလွယ်တကူ ပြန်ဖြစ်စေနိုင်ပါတယ်။ အခြားတောင်းဆိုမှု စလိုက်တာနဲ့ အဲဒီချိတ်ဆက်မှု အလိုလို မလွတ်ပါ။

Streaming response အတွက် ဘယ်သူတာဝန်ရှိလဲ ရှင်းလင်းပါ

import httpx

limits = httpx.Limits(
    max_connections=1,
    max_keepalive_connections=1,
)
timeout = httpx.Timeout(
    connect=5, read=10, write=10, pool=1
)

with httpx.Client(
    proxy="http://203.0.113.10:8080",
    trust_env=False,
    limits=limits,
    timeout=timeout,
) as client:
    with client.stream("GET", "https://example.com/") as response:
        print(response.status_code)
        for chunk in response.iter_bytes():
            print(len(chunk))

    next_response = client.get("https://example.com/")
    print(next_response.status_code)

မလုပ်ဆောင်ခင် စာတမ်းဥပမာပရောက်စီလိပ်စာကို ပြောင်းပါ။ နောက်တောင်းဆိုမှုက stream context ကနေ ထွက်ပြီးနောက် စပါတယ်။ ကုဒ်က loop ကို ဖြတ်ထွက်တာ ဒါမှမဟုတ် exception ပေးတာဖြစ်ရင်လည်း context ကနေ ထွက်တာက response ကို ပိတ်ပါတယ်။

client.send(request, stream=True) လို manual streaming မှာ နောက်ဆုံးပိတ်ဖို့ သင့်ကုဒ်က တာဝန်ယူရပါတယ်။ AsyncClient အတွက် သက်ဆိုင်တဲ့ manual cleanup ကို response.aclose() နဲ့ await လုပ်ပါတယ်။ မဖတ်ရသေးတဲ့ response ပိတ်ရင် နေရာလွတ်ပေမဲ့ အောက်ခံချိတ်ဆက်မှုကို ပြန်သုံးမယ့်အစား စွန့်ပစ်ရနိုင်ပါတယ်။

Exception နာမည်ကို ဖတ်ပါ

ConnectTimeout က ချိတ်ဆက်မှုတည်ဆောက်ခြင်းနဲ့ ဆိုင်ပါတယ်။ ReadTimeout က response data စောင့်ခြင်းနဲ့ ဆိုင်ပါတယ်။ PoolTimeout က ချိတ်ဆက်နေရာရခြင်းနဲ့ ဆိုင်ပါတယ်။ «ပရောက်စီအချိန်ကုန်» လို့ပဲ မှတ်ရင် ပြင်ဆင်နည်းရွေးဖို့ လိုတဲ့ကွာခြားချက် ပျောက်သွားပါတယ်။

ချိတ်ဆက်အမှတ် IP တွေ မပြောင်းခင် ဖွင့်ထားတဲ့ response၊ တစ်ပြိုင်နက် task တွေနဲ့ ချိတ်ဆက်မှုကန့်သတ်ချက်ကို စစ်ပါ။ သင့်တော်တဲ့ တစ်ပြိုင်နက်အလုပ်ဝန်အတွက် pool ပိုကြီးတာ သင့်နိုင်ပေမဲ့ မပိတ်တဲ့ response တွေကို မပြင်ပေးပါ။ အက်ပ်က ပိုသိမ်းထားနိုင်အောင် နေရာပေးတာပဲ ဖြစ်ပါတယ်။

အလုပ်ဝန်တစ်လျှောက် client ကို ပြန်သုံးနိုင်အောင် ထိန်းထားပါ။ တောင်းဆိုမှုတစ်ခုစီ အလုပ်လုပ်သလိုမြင်ဖို့ client ပြန်ဆောက်တာက lifecycle ပြဿနာကို ဖုံးကွယ်ပြီး ချိတ်ဆက်မှုပြန်သုံးမှုကို ဆုံးရှုံးစေနိုင်ပါတယ်။