Go मधील सामायिक राउंड-रोबिन प्रॉक्सी निवडक

निवडक अगदी नीट फिरू शकतो आणि तरीही पहिलाच प्रॉक्सी निवडत राहू शकतो. चूक ही आहे की प्रत्येक विनंतीसाठी नकळत नवीन निवडक तयार होतो, जो दुसरी निवड करण्यापूर्वीच त्याचा काउंटर रीसेट करतो.

निवडक एकदाच तयार करा आणि तो ट्रान्सपोर्टसोबत ठेवा. HTTP प्रॉक्सी यादी विनंत्या सार्वजनिक मध्यस्थांना परवानगी देत असतील तेव्हा URL संचासाठी सार्वजनिक HTTP उमेदवार पुरवू शकते. आधीच पडताळलेल्या, रिकाम्या नसलेल्या प्रॉक्सी URL यादीपासून सुरुवात करा:

func rotatingProxy(urls []*url.URL) func(*http.Request) (*url.URL, error) {
    var mu sync.Mutex
    next := 0
    return func(*http.Request) (*url.URL, error) {
        mu.Lock()
        selected := urls[next]
        next = (next + 1) % len(urls)
        mu.Unlock()
        return selected, nil
    }
}

आजूबाजूच्या अनुप्रयोगाने रिकामी यादी नाकारली पाहिजे, URL पडताळली पाहिजेत आणि नेहमीचे net/http, net/url व sync आयात वापरले पाहिजेत. हा निवडक ती वापरत असताना यादी अपरिवर्तनीय राहिली पाहिजे, किंवा स्वतंत्रपणे सिंक्रोनाइझ केलेल्या रचनेने बदलली पाहिजे.

परत मिळालेले फंक्शन एका ठेवलेल्या http.Transport ला जोडा. म्युटेक्स एकाच वेळी होणाऱ्या कॉलबॅकमधील निवडीचा क्रम संरक्षित करतो. संथ नेटवर्क विनंती पूर्ण होत असताना लॉक धरून ठेवण्याची आवश्यकता नसते.

फक्त छापण्यासाठी मार्ग वापरू नका

निदान संदेशासाठी निवडक पुन्हा हाक मारल्याने काउंटर पुन्हा पुढे जातो. ते आउटपुट तुम्ही तपासत असलेल्या विनंतीने वापरलेल्या उमेदवाराऐवजी पुढील उमेदवाराचे वर्णन करू शकते. खऱ्या कॉलबॅकमध्ये सुरक्षित एंडपॉइंट ओळखकर्त्यासह निवड नोंदवा.

कॉलबॅक हाक मारणे म्हणजे विनंती यशस्वीरित्या पोहोचली याचा पुरावा नाही. पुनर्निर्देशन किंवा अतिरिक्त ट्रान्सपोर्ट प्रयत्न “एक अनुप्रयोग हाक, एक निवड” या साध्या गृहीताला गुंतागुंतीचे करू शकतात. जर कार्यप्रवाहाला अनेक क्रियांमध्ये एक मार्ग टिकवायचा असेल, तर जागतिक फिरणारा कॉलबॅक वापरण्याऐवजी कार्यप्रवाहाच्या सीमेवर तो मार्ग निवडा.

राउंड-रोबिन वेगवेगळ्या सार्वजनिक निर्गमांचेही वचन देत नाही. ते एंडपॉइंट्सचे नियोजन करते. अंतिम ओळख प्रत्येक एंडपॉइंट पुरवत असलेल्या मार्गाचा गुणधर्म राहते.