מחליפֿן Go HTTP פּראָקסי רוטעס אָן ענדערן Client.Transport

אויב אַ http.Client ווערט שוין געטיילט דורך פּאַראַלעלע בקשות, האַלט זײַן Transport פֿעלד סטאַביל. דער אַרומנעם קען סינכראָניזירן וועלכן פֿול־קאָנפֿיגורירטן טראַנספּאָרט יעדע שפּעטערדיקע רייַז באַקומען:

type routeSlot struct {
    mu sync.RWMutex
    current http.RoundTripper
}

func (s *routeSlot) RoundTrip(r *http.Request) (*http.Response, error) {
    s.mu.RLock()
    current := s.current
    s.mu.RUnlock()
    return current.RoundTrip(r)
}

func (s *routeSlot) Set(next http.RoundTripper) {
    s.mu.Lock()
    s.current = next
    s.mu.Unlock()
}

מיט net/http און sync, איניציאַליזירט אים פֿאַר מען פֿאַרעפֿנטלעכט דעם קליענט:

slot := &routeSlot{current: initialTransport}
client := &http.Client{Transport: slot}

slot.Set(nextTransport)

initialTransport און nextTransport מוזן זײַן נישט-nil, פֿול־קאָנפֿיגורירט און זיכער פֿאַר פּאַראַלעליזם. בויט יעדן פּראָקסי טראַנספּאָרט פֿאַר מען פֿאַרעפֿנטלעכט אים, און לאָזט זײַן קאָנפֿיגוראַציע אומגעענדערט בשעת בקשות ניצן אים.

די שלאָס באַשיצט נאָר דעם פּנים־בילד פֿונעם פּײַנטער, דערפֿאַר האַלט אַ פּאַמעלעכע בקשה נישט די רוטירונג־שלאָס במשך איר גאַנצן נעצווערק־ווײַזל. אַ בקשה וואָס ניצט שוין דעם פֿריִערדיקן פּנים־בילד פֿירט ווײַטער אויף יענעם טראַנספּאָרט; דער ווײַזל שפּילט זי נישט איבער און פֿאַררוקט נישט איר פֿאַרבינדונג.

האַלט און שטעלט אָפּ אַלטע טראַנספּאָרטן דורך דעם באַגרענעצטן לעבנס־ציקל פֿון דער אַפּליקאַציע, לאָזט פֿאָרן באַשעפֿטיקונגען פֿאַרענדיקן זיך און פֿאַרמאַכט אַרבעטסלאָזע באַסיינס ווען עס פּאַסט. אַ ווײַטערפֿירונג קען פֿאַראורזאַכן נאָך אַ RoundTrip נאָך אַ ווײַזל. אויב אַ גאַנצער אַרבעטספֿלוס דאַרף איין רוטע, באַשטימט די רוטע בײַ דער גרענעץ פֿונעם אַרבעטספֿלוס אַנשטאָט ענדערן דעם געמיינזאַמען ווײַלער אין מיטן וועג.