Python-ൽ itertools.cycle ഉപയോഗിച്ചുള്ള round-robin പ്രോക്സി തിരഞ്ഞെടുപ്പ്

സ്ഥിരമായ ഒരു പൂളിന് round-robin തിരഞ്ഞെടുപ്പ് സുഖകരമായി ചെറുതായിരിക്കാം:

from itertools import cycle

choices = cycle([
    "http://proxy-a.example:8080",
    "http://proxy-b.example:8080",
    "http://proxy-c.example:8080",
])

endpoint = next(choices)

മാതൃകാ URL-കൾ നിങ്ങളുടെ സേവനത്തിൽ നിന്നോ HTTP പ്രോക്സി പട്ടികയിൽ നിന്നോ ഉള്ള HTTP എൻഡ്പോയിന്റുകൾ കൊണ്ട് മാറ്റുക. തുടർച്ചയായ കോളുകൾ A, B, C, തുടർന്ന് വീണ്ടും A നൽകുന്നു. അടുത്ത അഭ്യർത്ഥന ക്രമീകരിക്കുമ്പോൾ തിരഞ്ഞെടുത്ത മൂല്യം ഉപയോഗിക്കുക. ഓരോ അഭ്യർത്ഥനയ്ക്കും ഇറ്ററേറ്റർ വീണ്ടും നിർമ്മിച്ചാൽ ക്രമം വീണ്ടും ആരംഭിക്കും. Requests-നായി, തിരഞ്ഞെടുത്ത എൻഡ്പോയിന്റ് അഭ്യർത്ഥനയിലേക്ക് നൽകുക.

പട്ടിക ഇഷ്ടമാണെങ്കിൽ, അതിലെ ആദ്യ ഇനം അവസാനത്തിലേക്ക് മാറ്റുക. pool.append(pool.pop()) അവസാന ഇനം നീക്കി ഉടൻ തന്നെ തിരികെ വയ്ക്കുന്നു; ആദ്യ ഇനം ഒരിക്കലും മാറുന്നില്ല. ക്യൂ പ്രവർത്തനം pool.append(pool.pop(0)) ആണ്, എന്നാൽ മുന്നിൽ നിന്ന് നീക്കുന്നത് ബാക്കിയുള്ള പട്ടികാ ഘടകങ്ങളെ നീക്കുന്നു.

ഇറ്ററേറ്ററിന് ബോധപൂർവം വിനയാന്വിതമായ ഒരു ജോലിയുണ്ട്. അത് ലഭ്യത പരിശോധിക്കുന്നില്ല, പരാജയപ്പെട്ട എൻട്രികൾ നീക്കുന്നില്ല, വ്യത്യസ്തമായ ഒരു പൊതു പുറത്തേക്കുള്ള വഴി ഉറപ്പാക്കുന്നുമില്ല. പല എൻഡ്പോയിന്റുകൾക്കും ഒരു പുറം വിലാസം പങ്കിടാം.

വീണ്ടും ശ്രമിക്കാനുള്ള നയവും പൂൾ അപ്ഡേറ്റുകളും ഈ ചെറിയ തിരഞ്ഞെടുക്കുന്നതിന് പുറത്ത് നിർത്തുക. പങ്കിടുന്ന ഇറ്ററേറ്ററിന് സമകാലിക കോഡിൽ ബോധപൂർവമായ ഉടമസ്ഥതാ മാതൃകയും ആവശ്യമാണ്, അതുവഴി തിരഞ്ഞെടുത്ത എൻഡ്പോയിന്റ് അത് സ്വീകരിച്ച പ്രവർത്തനത്തോട് ബന്ധിപ്പിച്ചിരിക്കും.