HTTPX PoolTimeout មិនមែនការអស់ពេលតភ្ជាប់ទៅប្រូកស៊ីទេ

PoolTimeout មានន័យថា HTTPX មិនអាចយកការតភ្ជាប់ពី pool ក្នុងពេលរង់ចាំដែលកំណត់។ វាមិនមែនភស្តុតាងថាការតភ្ជាប់ TCP ថ្មីទៅប្រូកស៊ីអស់ពេលទេ។ សំណើទីពីរអាចនៅតែរង់ចាំក្នុងដំណើរការរបស់អ្នក។

រឿងនេះងាយបង្កើតឡើងវិញពេល client អនុញ្ញាតតែមួយការតភ្ជាប់ ហើយការឆ្លើយតប streaming ដំបូងត្រូវទុកបើក។ ចាប់ផ្តើមសំណើមួយទៀតមិនដោះលែងការតភ្ជាប់នោះដោយខ្លួនឯងទេ។

បញ្ជាក់អ្នកទទួលខុសត្រូវលើការឆ្លើយតប streaming

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។ ការចេញនេះបិទការឆ្លើយតប ទោះកូដចេញពីរង្វិលជុំ ឬបង្កើតករណីលើកលែងក៏ដោយ។

ក្នុង streaming ដោយដៃ ដូចជា client.send(request, stream=True) កូដអ្នកទទួលខុសត្រូវលើការបិទចុងក្រោយ។ សម្រាប់ AsyncClient ការសម្អាតដោយដៃដែលត្រូវគ្នាត្រូវរង់ចាំដោយ response.aclose()។ បិទការឆ្លើយតបដែលមិនបានអានដោះលែងសមត្ថភាព ប៉ុន្តែអាចត្រូវបោះបង់ការតភ្ជាប់មូលដ្ឋានជំនួសការប្រើឡើងវិញ។

អានឈ្មោះករណីលើកលែង

ConnectTimeout ទាក់ទងនឹងការបង្កើតការតភ្ជាប់។ ReadTimeout ទាក់ទងនឹងការរង់ចាំទិន្នន័យឆ្លើយតប។ PoolTimeout ទាក់ទងនឹងការទទួលកន្លែងតភ្ជាប់។ កត់តែ «ប្រូកស៊ីអស់ពេល» នឹងបាត់ភាពខុសគ្នាចាំបាច់សម្រាប់ជ្រើសវិធីកែ។

ពិនិត្យការឆ្លើយតបដែលបើក កិច្ចការស្របគ្នា និងដែនកំណត់ការតភ្ជាប់មុនប្តូរ IP ចំណុចតភ្ជាប់។ pool ធំអាចសមរម្យសម្រាប់បន្ទុកស្របគ្នាដែលសមហេតុផល ប៉ុន្តែមិនជួសជុលការឆ្លើយតបដែលមិនដែលបិទទេ។ វាគ្រាន់តែផ្តល់សមត្ថភាពច្រើនឡើងឱ្យកម្មវិធីកាន់កាប់។

រក្សា client ឱ្យប្រើឡើងវិញបានក្នុងបន្ទុកទាំងមូល។ បង្កើត client ឡើងវិញដើម្បីឱ្យសំណើនីមួយៗមើលទៅដំណើរការអាចលាក់បញ្ហាវដ្តជីវិត និងបាត់ការប្រើការតភ្ជាប់ឡើងវិញ។