അഞ്ച് വിദ്യാർത്ഥികളും മൂന്ന് പേർ താക്കോൽ മൂല്യമുള്ള സ്റ്റോറുകളും വിതരണം ചെയ്തു

അല്ലെങ്കിൽ ZooKeeper, etcd, കോൺസൽ KV എന്നിവയ്‌ക്കായി ഞങ്ങൾ എങ്ങനെയാണ് ഒരു ക്ലയൻ്റ് C++ ലൈബ്രറി എഴുതിയത്

വിതരണം ചെയ്ത സിസ്റ്റങ്ങളുടെ ലോകത്ത്, നിരവധി സാധാരണ ജോലികൾ ഉണ്ട്: ക്ലസ്റ്ററിൻ്റെ ഘടനയെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംഭരിക്കുക, നോഡുകളുടെ കോൺഫിഗറേഷൻ കൈകാര്യം ചെയ്യുക, തെറ്റായ നോഡുകൾ കണ്ടെത്തുക, ഒരു നേതാവിനെ തിരഞ്ഞെടുക്കൽ മറ്റുള്ളവരും. ഈ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന്, പ്രത്യേക വിതരണ സംവിധാനങ്ങൾ സൃഷ്ടിച്ചു - ഏകോപന സേവനങ്ങൾ. ഇപ്പോൾ നമുക്ക് അവയിൽ മൂന്നെണ്ണത്തിൽ താൽപ്പര്യമുണ്ടാകും: ZooKeeper, etcd, കോൺസൽ. കോൺസലിൻ്റെ എല്ലാ സമ്പന്നമായ പ്രവർത്തനങ്ങളിൽ നിന്നും, ഞങ്ങൾ കോൺസൽ കെ.വി.

സാരാംശത്തിൽ, ഈ സംവിധാനങ്ങളെല്ലാം തെറ്റ്-സഹിഷ്ണുതയുള്ളതും രേഖീയമാക്കാവുന്നതുമായ കീ-മൂല്യം സ്റ്റോറുകളാണ്. അവരുടെ ഡാറ്റ മോഡലുകൾക്ക് കാര്യമായ വ്യത്യാസങ്ങളുണ്ടെങ്കിലും, അത് ഞങ്ങൾ പിന്നീട് ചർച്ച ചെയ്യും, അവ ഒരേ പ്രായോഗിക പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു. വ്യക്തമായും, കോർഡിനേഷൻ സേവനം ഉപയോഗിക്കുന്ന ഓരോ ആപ്ലിക്കേഷനും അവയിലൊന്നുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, ഇത് വ്യത്യസ്ത ആപ്ലിക്കേഷനുകൾക്കുള്ള ഒരേ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്ന ഒരു ഡാറ്റാ സെൻ്ററിൽ നിരവധി സിസ്റ്റങ്ങളെ പിന്തുണയ്ക്കേണ്ടതിൻ്റെ ആവശ്യകതയിലേക്ക് നയിച്ചേക്കാം.

ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള ആശയം ഒരു ഓസ്‌ട്രേലിയൻ കൺസൾട്ടിംഗ് ഏജൻസിയിൽ നിന്നാണ് ഉത്ഭവിച്ചത്, ഇത് നടപ്പിലാക്കാൻ ഞങ്ങൾ, ഒരു ചെറിയ വിദ്യാർത്ഥി ടീമിന് വീണു, അതിനെക്കുറിച്ചാണ് ഞാൻ സംസാരിക്കാൻ പോകുന്നത്.

ZooKeeper, etcd, കോൺസൽ കെവി എന്നിവരുമായി പ്രവർത്തിക്കുന്നതിന് ഒരു പൊതു ഇൻ്റർഫേസ് നൽകുന്ന ഒരു ലൈബ്രറി സൃഷ്ടിക്കാൻ ഞങ്ങൾക്ക് കഴിഞ്ഞു. ലൈബ്രറി C++ ൽ എഴുതിയിരിക്കുന്നു, എന്നാൽ ഇത് മറ്റ് ഭാഷകളിലേക്ക് പോർട്ട് ചെയ്യാൻ പദ്ധതിയുണ്ട്.

ഡാറ്റ മോഡലുകൾ

മൂന്ന് വ്യത്യസ്ത സിസ്റ്റങ്ങൾക്കായി ഒരു പൊതു ഇൻ്റർഫേസ് വികസിപ്പിക്കുന്നതിന്, അവയ്ക്ക് പൊതുവായുള്ളത് എന്താണെന്നും അവ എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നുവെന്നും നിങ്ങൾ മനസ്സിലാക്കേണ്ടതുണ്ട്. നമുക്ക് അത് കണ്ടുപിടിക്കാം.

മൃഗശാല സൂക്ഷിപ്പുകാരൻ

കീകൾ ഒരു മരത്തിൽ ക്രമീകരിച്ചിരിക്കുന്നു, അവയെ നോഡുകൾ എന്ന് വിളിക്കുന്നു. അതനുസരിച്ച്, ഒരു നോഡിനായി നിങ്ങൾക്ക് അതിൻ്റെ കുട്ടികളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കും. ഒരു znode സൃഷ്ടിക്കുന്നതിനും (സൃഷ്ടിക്കുന്നതിനും) ഒരു മൂല്യം (setData) മാറ്റുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾ വേർതിരിച്ചിരിക്കുന്നു: നിലവിലുള്ള കീകൾ മാത്രമേ വായിക്കാനും മാറ്റാനും കഴിയൂ. ഒരു നോഡിൻ്റെ അസ്തിത്വം പരിശോധിക്കുന്നതിനും ഒരു മൂല്യം വായിക്കുന്നതിനും കുട്ടികളെ നേടുന്നതിനുമുള്ള പ്രവർത്തനങ്ങളിൽ വാച്ചുകൾ ഘടിപ്പിക്കാം. സെർവറിലെ അനുബന്ധ ഡാറ്റയുടെ പതിപ്പ് മാറുമ്പോൾ ഫയർ ചെയ്യുന്ന ഒറ്റത്തവണ ട്രിഗറാണ് വാച്ച്. പരാജയങ്ങൾ കണ്ടുപിടിക്കാൻ എഫെമറൽ നോഡുകൾ ഉപയോഗിക്കുന്നു. അവ സൃഷ്ടിച്ച ക്ലയൻ്റിൻ്റെ സെഷനുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഒരു ക്ലയൻ്റ് ഒരു സെഷൻ അടയ്ക്കുകയോ ZooKeeper-ൻ്റെ നിലനിൽപ്പ് അറിയിക്കുന്നത് നിർത്തുകയോ ചെയ്യുമ്പോൾ, ഈ നോഡുകൾ സ്വയമേവ ഇല്ലാതാക്കപ്പെടും. ലളിതമായ ഇടപാടുകൾ പിന്തുണയ്ക്കുന്നു - അവയിലൊന്നിന് എങ്കിലും ഇത് സാധ്യമല്ലെങ്കിൽ എല്ലാം വിജയിക്കുന്നതോ പരാജയപ്പെടുന്നതോ ആയ പ്രവർത്തനങ്ങളുടെ ഒരു കൂട്ടം.

തുടങ്ങിയവ

ഈ സിസ്റ്റത്തിൻ്റെ ഡെവലപ്പർമാർ വ്യക്തമായി ZooKeeper-ൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടിരുന്നു, അതിനാൽ എല്ലാം വ്യത്യസ്തമായി ചെയ്തു. കീകളുടെ ഒരു ശ്രേണിയും ഇല്ല, പക്ഷേ അവ നിഘണ്ടുവിൽ ക്രമീകരിച്ചിരിക്കുന്ന ഒരു സെറ്റ് ഉണ്ടാക്കുന്നു. ഒരു നിശ്ചിത ശ്രേണിയിലുള്ള എല്ലാ കീകളും നിങ്ങൾക്ക് നേടാനോ ഇല്ലാതാക്കാനോ കഴിയും. ഈ ഘടന വിചിത്രമായി തോന്നിയേക്കാം, എന്നാൽ ഇത് യഥാർത്ഥത്തിൽ വളരെ പ്രകടമാണ്, കൂടാതെ ഒരു ശ്രേണിപരമായ വീക്ഷണം അതിലൂടെ എളുപ്പത്തിൽ അനുകരിക്കാനാകും.

etcd-ന് ഒരു സ്റ്റാൻഡേർഡ് താരതമ്യപ്പെടുത്തൽ പ്രവർത്തനമില്ല, പക്ഷേ അതിന് മികച്ച ചിലത് ഉണ്ട്: ഇടപാടുകൾ. തീർച്ചയായും, അവ മൂന്ന് സിസ്റ്റങ്ങളിലും നിലവിലുണ്ട്, എന്നാൽ etcd ഇടപാടുകൾ പ്രത്യേകിച്ചും നല്ലതാണ്. അവയിൽ മൂന്ന് ബ്ലോക്കുകൾ അടങ്ങിയിരിക്കുന്നു: പരിശോധന, വിജയം, പരാജയം. ആദ്യ ബ്ലോക്കിൽ ഒരു കൂട്ടം വ്യവസ്ഥകൾ അടങ്ങിയിരിക്കുന്നു, രണ്ടാമത്തേതും മൂന്നാമത്തേതും - പ്രവർത്തനങ്ങൾ. ഇടപാട് ആറ്റോമികമായി നടപ്പിലാക്കുന്നു. എല്ലാ വ്യവസ്ഥകളും ശരിയാണെങ്കിൽ, സക്സസ് ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും, അല്ലാത്തപക്ഷം പരാജയ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. API 3.3-ൽ, വിജയ പരാജയ ബ്ലോക്കുകളിൽ നെസ്റ്റഡ് ഇടപാടുകൾ അടങ്ങിയിരിക്കാം. അതായത്, ഏതാണ്ട് ഏകപക്ഷീയമായ നെസ്റ്റിംഗ് ലെവലിൻ്റെ സോപാധികമായ നിർമ്മിതികൾ ആറ്റോമിക് എക്സിക്യൂട്ട് ചെയ്യാൻ സാധിക്കും. എന്തൊക്കെ പരിശോധനകളും പ്രവർത്തനങ്ങളും നിലവിലുണ്ട് എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതലറിയാൻ കഴിയും പ്രമാണീകരണം.

വാച്ചുകൾ ഇവിടെയും നിലവിലുണ്ട്, അവ കുറച്ചുകൂടി സങ്കീർണ്ണവും വീണ്ടും ഉപയോഗിക്കാവുന്നതുമാണ്. അതായത്, ഒരു കീ ശ്രേണിയിൽ ഒരു വാച്ച് ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, നിങ്ങൾ വാച്ച് റദ്ദാക്കുന്നത് വരെ ഈ ശ്രേണിയിലെ എല്ലാ അപ്‌ഡേറ്റുകളും നിങ്ങൾക്ക് ലഭിക്കും, ആദ്യത്തേത് മാത്രമല്ല. മുതലായവയിൽ, ZooKeeper ക്ലയൻ്റ് സെഷനുകളുടെ അനലോഗ് പാട്ടങ്ങളാണ്.

കോൺസൽ കെ.വി.

ഇവിടെ കർശനമായ ശ്രേണിപരമായ ഘടനയും ഇല്ല, പക്ഷേ കോൺസലിന് അത് നിലനിൽക്കുന്ന രൂപം സൃഷ്ടിക്കാൻ കഴിയും: നിർദ്ദിഷ്ട പ്രിഫിക്സ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് എല്ലാ കീകളും നേടാനും ഇല്ലാതാക്കാനും കഴിയും, അതായത്, കീയുടെ "സബ്ട്രീ" ഉപയോഗിച്ച് പ്രവർത്തിക്കുക. അത്തരം അന്വേഷണങ്ങളെ റിക്കേഴ്‌സീവ് എന്ന് വിളിക്കുന്നു. കൂടാതെ, പ്രിഫിക്‌സിന് ശേഷം നിർദ്ദിഷ്ട പ്രതീകം അടങ്ങിയിട്ടില്ലാത്ത കീകൾ മാത്രമേ കോൺസൽ തിരഞ്ഞെടുക്കാൻ കഴിയൂ, അത് ഉടനടി "കുട്ടികൾ" നേടുന്നതിന് അനുയോജ്യമാണ്. എന്നാൽ ഇത് കൃത്യമായി ഒരു ശ്രേണി ഘടനയുടെ രൂപമാണെന്ന് ഓർമ്മിക്കേണ്ടതാണ്: അതിൻ്റെ രക്ഷകർത്താവ് നിലവിലില്ലെങ്കിൽ ഒരു കീ സൃഷ്ടിക്കുകയോ കുട്ടികളുള്ള ഒരു കീ ഇല്ലാതാക്കുകയോ ചെയ്യുന്നത് തികച്ചും സാദ്ധ്യമാണ്, അതേസമയം കുട്ടികൾ സിസ്റ്റത്തിൽ സൂക്ഷിക്കുന്നത് തുടരും.

വാച്ചുകൾക്ക് പകരം, കോൺസൽ HTTP അഭ്യർത്ഥനകൾ തടയുന്നു. സാരാംശത്തിൽ, ഇവ ഡാറ്റ റീഡിംഗ് രീതിയിലേക്കുള്ള സാധാരണ കോളുകളാണ്, ഇതിനായി, മറ്റ് പാരാമീറ്ററുകൾക്കൊപ്പം, ഡാറ്റയുടെ അവസാനത്തെ അറിയപ്പെടുന്ന പതിപ്പ് സൂചിപ്പിച്ചിരിക്കുന്നു. സെർവറിലെ അനുബന്ധ ഡാറ്റയുടെ നിലവിലെ പതിപ്പ് വ്യക്തമാക്കിയതിനേക്കാൾ വലുതാണെങ്കിൽ, പ്രതികരണം ഉടനടി നൽകും, അല്ലാത്തപക്ഷം - മൂല്യം മാറുമ്പോൾ. എപ്പോൾ വേണമെങ്കിലും കീകളിൽ ഘടിപ്പിക്കാവുന്ന സെഷനുകളും ഉണ്ട്. സെഷനുകൾ ഇല്ലാതാക്കുന്നത് അനുബന്ധ കീകൾ ഇല്ലാതാക്കുന്നതിലേക്ക് നയിക്കുന്ന etcd, ZooKeeper എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി, സെഷൻ അവയിൽ നിന്ന് അൺലിങ്ക് ചെയ്യാത്ത ഒരു മോഡ് ഉണ്ടെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ലഭ്യമാണ് ഇടപാടുകൾ, ശാഖകളില്ലാതെ, എന്നാൽ എല്ലാത്തരം പരിശോധനകളും.

അതെല്ലാം ഒന്നിച്ചു ചേർക്കുന്നു

ZooKeeper-ന് ഏറ്റവും കർശനമായ ഡാറ്റ മോഡൽ ഉണ്ട്. തുടങ്ങിയവയിൽ ലഭ്യമായ എക്സ്പ്രസീവ് റേഞ്ച് അന്വേഷണങ്ങൾ ZooKeeper അല്ലെങ്കിൽ Consul എന്നിവയിൽ ഫലപ്രദമായി അനുകരിക്കാൻ കഴിയില്ല. എല്ലാ സേവനങ്ങളിൽ നിന്നും ഏറ്റവും മികച്ചത് എടുക്കാൻ ശ്രമിച്ചുകൊണ്ട്, ഇനിപ്പറയുന്ന പ്രധാനപ്പെട്ട ഒഴിവാക്കലുകളോടെ ZooKeeper ഇൻ്റർഫേസിന് ഏതാണ്ട് തുല്യമായ ഒരു ഇൻ്റർഫേസ് ഞങ്ങൾ അവസാനിപ്പിച്ചു:

• ക്രമം, കണ്ടെയ്നർ, TTL നോഡുകൾ പിന്തുണയ്ക്കുന്നില്ല
• ACL-കൾ പിന്തുണയ്ക്കുന്നില്ല
• സെറ്റ് രീതി നിലവിലില്ലെങ്കിൽ ഒരു കീ സൃഷ്ടിക്കുന്നു (ZK setData ഈ കേസിൽ ഒരു പിശക് നൽകുന്നു)
• സെറ്റും കാസ് രീതികളും വേർതിരിച്ചിരിക്കുന്നു (ZK-യിൽ അവ അടിസ്ഥാനപരമായി ഒന്നുതന്നെയാണ്)
• മായ്‌ക്കൽ രീതി അതിൻ്റെ സബ്‌ട്രീയ്‌ക്കൊപ്പം ഒരു നോഡ് ഇല്ലാതാക്കുന്നു (ZK ഡിലീറ്റ് നോഡിന് കുട്ടികളുണ്ടെങ്കിൽ ഒരു പിശക് നൽകുന്നു)
• ഓരോ കീയ്ക്കും ഒരു പതിപ്പ് മാത്രമേയുള്ളൂ - മൂല്യ പതിപ്പ് (ZK-ൽ അവയിൽ മൂന്നെണ്ണം ഉണ്ട്)

സീക്വൻഷ്യൽ നോഡുകളുടെ നിരസിക്കലിന് കാരണം etcd, കോൺസൽ എന്നിവയ്ക്ക് അന്തർനിർമ്മിത പിന്തുണ ഇല്ല എന്നതും, തത്ഫലമായുണ്ടാകുന്ന ലൈബ്രറി ഇൻ്റർഫേസിന് മുകളിൽ ഉപയോക്താവിന് അവ എളുപ്പത്തിൽ നടപ്പിലാക്കാൻ കഴിയും.

ഒരു ശീർഷകം ഇല്ലാതാക്കുമ്പോൾ ZooKeeper പോലെയുള്ള പെരുമാറ്റം നടപ്പിലാക്കുന്നതിന് etcd, കോൺസൽ എന്നിവയിലെ ഓരോ കീയ്ക്കും പ്രത്യേക ചൈൽഡ് കൗണ്ടർ പരിപാലിക്കേണ്ടതുണ്ട്. മെറ്റാ വിവരങ്ങൾ സംഭരിക്കുന്നത് ഒഴിവാക്കാൻ ഞങ്ങൾ ശ്രമിച്ചതിനാൽ, മുഴുവൻ സബ്ട്രീയും ഇല്ലാതാക്കാൻ തീരുമാനിച്ചു.

നടപ്പാക്കലിൻ്റെ സൂക്ഷ്മതകൾ

വ്യത്യസ്ത സിസ്റ്റങ്ങളിൽ ലൈബ്രറി ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നതിൻ്റെ ചില വശങ്ങൾ നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം.

മുതലായവയിലെ ശ്രേണി

etcd-യിൽ ഒരു ശ്രേണിപരമായ കാഴ്ച നിലനിർത്തുന്നത് ഏറ്റവും രസകരമായ ഒരു ജോലിയായി മാറി. റേഞ്ച് അന്വേഷണങ്ങൾ ഒരു നിർദ്ദിഷ്‌ട പ്രിഫിക്‌സുള്ള കീകളുടെ ഒരു ലിസ്റ്റ് വീണ്ടെടുക്കുന്നത് എളുപ്പമാക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ആരംഭിക്കുന്ന എല്ലാം വേണമെങ്കിൽ "/foo", നിങ്ങൾ ഒരു ശ്രേണി ആവശ്യപ്പെടുന്നു ["/foo", "/fop"). എന്നാൽ ഇത് കീയുടെ മുഴുവൻ സബ്ട്രീയും തിരികെ നൽകും, സബ്ട്രീ വലുതാണെങ്കിൽ അത് സ്വീകാര്യമായേക്കില്ല. ആദ്യം ഞങ്ങൾ ഒരു പ്രധാന വിവർത്തന സംവിധാനം ഉപയോഗിക്കാൻ പദ്ധതിയിട്ടിരുന്നു, zetcd-ൽ നടപ്പിലാക്കി. ട്രീയിലെ നോഡിൻ്റെ ആഴത്തിന് തുല്യമായ കീയുടെ തുടക്കത്തിൽ ഒരു ബൈറ്റ് ചേർക്കുന്നത് ഇതിൽ ഉൾപ്പെടുന്നു. ഞാനൊരു ഉദാഹരണം പറയാം.

"/foo" -> "u01/foo"
"/foo/bar" -> "u02/foo/bar"

അപ്പോൾ കീയുടെ എല്ലാ ഉടനടി കുട്ടികളും നേടുക "/foo" ഒരു ശ്രേണി അഭ്യർത്ഥിക്കുന്നതിലൂടെ സാധ്യമാണ് ["u02/foo/", "u02/foo0"). അതെ, ASCII-ൽ "0" തൊട്ടുപിന്നാലെ നിൽക്കുന്നു "/".

എന്നാൽ ഈ കേസിൽ ഒരു ശീർഷകം നീക്കം ചെയ്യുന്നത് എങ്ങനെ നടപ്പാക്കാം? ഈ തരത്തിലുള്ള എല്ലാ ശ്രേണികളും നിങ്ങൾ ഇല്ലാതാക്കേണ്ടതുണ്ടെന്ന് ഇത് മാറുന്നു ["uXX/foo/", "uXX/foo0") XX-ന് 01 മുതൽ FF വരെ. എന്നിട്ട് ഞങ്ങൾ അകത്തേക്ക് ഓടി ഓപ്പറേഷൻ നമ്പർ പരിധി ഒരു ഇടപാടിനുള്ളിൽ.

തൽഫലമായി, ഒരു ലളിതമായ കീ പരിവർത്തന സംവിധാനം കണ്ടുപിടിച്ചു, ഇത് ഒരു കീ ഇല്ലാതാക്കുന്നതും കുട്ടികളുടെ പട്ടിക നേടുന്നതും ഫലപ്രദമായി നടപ്പിലാക്കുന്നത് സാധ്യമാക്കി. അവസാനത്തെ ടോക്കണിന് മുമ്പ് ഒരു പ്രത്യേക പ്രതീകം ചേർത്താൽ മതി. ഉദാഹരണത്തിന്:

"/very" -> "/u00very"
"/very/long" -> "/very/u00long"
"/very/long/path" -> "/very/long/u00path"

തുടർന്ന് കീ ഇല്ലാതാക്കുന്നു "/very" ഇല്ലാതാക്കലായി മാറുന്നു "/u00very" ശ്രേണിയും ["/very/", "/very0"), കൂടാതെ എല്ലാ കുട്ടികളെയും - ശ്രേണിയിൽ നിന്നുള്ള കീകൾക്കായുള്ള അഭ്യർത്ഥനയിൽ ["/very/u00", "/very/u01").

ZooKeeper-ൽ ഒരു കീ നീക്കംചെയ്യുന്നു

ഞാൻ ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, ZooKeeper-ൽ നിങ്ങൾക്ക് കുട്ടികളുണ്ടെങ്കിൽ ഒരു നോഡ് ഇല്ലാതാക്കാൻ കഴിയില്ല. സബ്‌ട്രീയ്‌ക്കൊപ്പം കീ ഇല്ലാതാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഞാൻ എന്ത് ചെയ്യണം? ശുഭാപ്തിവിശ്വാസത്തോടെയാണ് ഞങ്ങൾ ഇത് ചെയ്യുന്നത്. ആദ്യം, ഞങ്ങൾ ഉപവൃക്ഷത്തിലൂടെ ആവർത്തിച്ച് സഞ്ചരിക്കുന്നു, ഓരോ ശീർഷകത്തിൻ്റെയും കുട്ടികളെ ഒരു പ്രത്യേക അന്വേഷണത്തിലൂടെ നേടുന്നു. തുടർന്ന് സബ്ട്രീയുടെ എല്ലാ നോഡുകളും ശരിയായ ക്രമത്തിൽ ഇല്ലാതാക്കാൻ ശ്രമിക്കുന്ന ഒരു ഇടപാട് ഞങ്ങൾ നിർമ്മിക്കുന്നു. തീർച്ചയായും, ഒരു സബ്ട്രീ വായിക്കുന്നതിനും അത് ഇല്ലാതാക്കുന്നതിനും ഇടയിൽ മാറ്റങ്ങൾ സംഭവിക്കാം. ഈ സാഹചര്യത്തിൽ, ഇടപാട് പരാജയപ്പെടും. മാത്രമല്ല, വായനാ പ്രക്രിയയിൽ സബ്ട്രീ മാറിയേക്കാം. ഉദാഹരണത്തിന്, ഈ നോഡ് ഇതിനകം ഇല്ലാതാക്കിയിട്ടുണ്ടെങ്കിൽ, അടുത്ത നോഡിൻ്റെ കുട്ടികൾക്കായുള്ള അഭ്യർത്ഥന ഒരു പിശക് നൽകാം. രണ്ട് സാഹചര്യങ്ങളിലും, ഞങ്ങൾ മുഴുവൻ പ്രക്രിയയും വീണ്ടും ആവർത്തിക്കുന്നു.

ഈ സമീപനം ഒരു കീ ഇല്ലാതാക്കുന്നത് വളരെ ഫലപ്രദമല്ലാതാക്കുന്നു, അതിന് കുട്ടികളുണ്ടെങ്കിൽ, അതിലും ഉപരിയായി ആപ്ലിക്കേഷൻ സബ്ട്രീയിൽ പ്രവർത്തിക്കുന്നത് തുടരുകയും കീകൾ ഇല്ലാതാക്കുകയും സൃഷ്ടിക്കുകയും ചെയ്യുന്നുവെങ്കിൽ. എന്നിരുന്നാലും, etcd, കോൺസൽ എന്നിവയിലെ മറ്റ് രീതികൾ നടപ്പിലാക്കുന്നത് സങ്കീർണ്ണമാക്കുന്നത് ഒഴിവാക്കാൻ ഇത് ഞങ്ങളെ അനുവദിച്ചു.

ZooKeeper ൽ സജ്ജീകരിച്ചിരിക്കുന്നു

ZooKeeper-ൽ ട്രീ ഘടനയുമായി പ്രവർത്തിക്കുന്ന പ്രത്യേക രീതികളുണ്ട് (സൃഷ്ടിക്കുക, ഇല്ലാതാക്കുക, നേടുക) കൂടാതെ നോഡുകളിലെ ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കുകയും ചെയ്യുന്നു (setData, getData), കൂടാതെ, എല്ലാ രീതികൾക്കും കർശനമായ മുൻവ്യവസ്ഥകൾ ഉണ്ട്: സൃഷ്‌ടിക്കൽ ഇതിനകം തന്നെ ഒരു പിശക് നൽകും സൃഷ്ടിച്ചു, ഇല്ലാതാക്കുക അല്ലെങ്കിൽ ഡാറ്റ സജ്ജമാക്കുക - ഇത് ഇതിനകം നിലവിലില്ലെങ്കിൽ. ഒരു കീയുടെ സാന്നിധ്യത്തെക്കുറിച്ച് ചിന്തിക്കാതെ വിളിക്കാവുന്ന ഒരു സെറ്റ് രീതി ഞങ്ങൾക്ക് ആവശ്യമായിരുന്നു.

ഇല്ലാതാക്കുന്നത് പോലെ ശുഭാപ്തിവിശ്വാസമുള്ള സമീപനമാണ് ഒരു ഓപ്ഷൻ. ഒരു നോഡ് നിലവിലുണ്ടോയെന്ന് പരിശോധിക്കുക. നിലവിലുണ്ടെങ്കിൽ, setData എന്ന് വിളിക്കുക, അല്ലെങ്കിൽ സൃഷ്ടിക്കുക. അവസാന രീതി ഒരു പിശക് നൽകുകയാണെങ്കിൽ, അത് വീണ്ടും ആവർത്തിക്കുക. അസ്തിത്വ പരിശോധന അർത്ഥശൂന്യമാണ് എന്നതാണ് ആദ്യം ശ്രദ്ധിക്കേണ്ടത്. നിങ്ങൾക്ക് ഉടൻ സൃഷ്ടിക്കാൻ വിളിക്കാം. വിജയകരമായ പൂർത്തീകരണം അർത്ഥമാക്കുന്നത് നോഡ് നിലവിലില്ല, അത് സൃഷ്ടിക്കപ്പെട്ടു എന്നാണ്. അല്ലെങ്കിൽ, സൃഷ്‌ടിക്കുന്നത് ഉചിതമായ പിശക് നൽകും, അതിനുശേഷം നിങ്ങൾ setData-യെ വിളിക്കേണ്ടതുണ്ട്. തീർച്ചയായും, കോളുകൾക്കിടയിൽ, ഒരു മത്സര കോൾ വഴി ഒരു വെർട്ടെക്സ് ഇല്ലാതാക്കാം, കൂടാതെ setData ഒരു പിശക് നൽകും. ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ഇത് വീണ്ടും ചെയ്യാൻ കഴിയും, പക്ഷേ അത് വിലമതിക്കുന്നുണ്ടോ?

രണ്ട് രീതികളും ഒരു പിശക് നൽകുന്നുവെങ്കിൽ, മത്സരിക്കുന്ന ഒരു ഇല്ലാതാക്കൽ നടന്നതായി ഞങ്ങൾക്ക് ഉറപ്പായും അറിയാം. കോളിംഗ് സെറ്റിന് ശേഷം ഈ ഇല്ലാതാക്കൽ സംഭവിച്ചതായി സങ്കൽപ്പിക്കുക. അപ്പോൾ നമ്മൾ സ്ഥാപിക്കാൻ ശ്രമിക്കുന്ന ഏത് അർത്ഥവും ഇതിനകം മായ്‌ച്ചിരിക്കുന്നു. യഥാർത്ഥത്തിൽ ഒന്നും എഴുതിയില്ലെങ്കിലും, സെറ്റ് വിജയകരമായി നിർവ്വഹിച്ചുവെന്ന് നമുക്ക് അനുമാനിക്കാം എന്നാണ് ഇതിനർത്ഥം.

കൂടുതൽ സാങ്കേതിക വിശദാംശങ്ങൾ

ഈ വിഭാഗത്തിൽ ഞങ്ങൾ വിതരണം ചെയ്ത സിസ്റ്റങ്ങളിൽ നിന്ന് ഇടവേള എടുത്ത് കോഡിംഗിനെക്കുറിച്ച് സംസാരിക്കും.
ഉപഭോക്താവിൻ്റെ പ്രധാന ആവശ്യങ്ങളിലൊന്ന് ക്രോസ്-പ്ലാറ്റ്ഫോമായിരുന്നു: കുറഞ്ഞത് ഒരു സേവനമെങ്കിലും Linux, MacOS, Windows എന്നിവയിൽ പിന്തുണയ്ക്കണം. തുടക്കത്തിൽ, ഞങ്ങൾ ലിനക്സിനായി മാത്രം വികസിപ്പിച്ചെടുത്തു, പിന്നീട് മറ്റ് സിസ്റ്റങ്ങളിൽ പരീക്ഷിക്കാൻ തുടങ്ങി. ഇത് വളരെയധികം പ്രശ്നങ്ങൾക്ക് കാരണമായി, ഇത് എങ്ങനെ സമീപിക്കണമെന്ന് കുറച്ച് സമയത്തേക്ക് പൂർണ്ണമായും വ്യക്തമല്ല. തൽഫലമായി, മൂന്ന് കോർഡിനേഷൻ സേവനങ്ങളും ഇപ്പോൾ Linux-ലും MacOS-ലും പിന്തുണയ്‌ക്കുന്നു, അതേസമയം Windows-ൽ കോൺസൽ KV മാത്രമേ പിന്തുണയ്‌ക്കൂ.

തുടക്കത്തിൽ തന്നെ, സേവനങ്ങൾ ആക്സസ് ചെയ്യാൻ ഞങ്ങൾ റെഡിമെയ്ഡ് ലൈബ്രറികൾ ഉപയോഗിക്കാൻ ശ്രമിച്ചു. ZooKeeper ൻ്റെ കാര്യത്തിൽ, തിരഞ്ഞെടുപ്പ് വീണു ZooKeeper C++, ഇത് ആത്യന്തികമായി വിൻഡോസിൽ കംപൈൽ ചെയ്യുന്നതിൽ പരാജയപ്പെട്ടു. എന്നിരുന്നാലും, ഇത് ആശ്ചര്യകരമല്ല: ലൈബ്രറി ലിനക്സ് മാത്രമായി സ്ഥാപിച്ചിരിക്കുന്നു. കോൺസലിന് ഒരേയൊരു ഓപ്ഷൻ മാത്രമായിരുന്നു ppconsul. അതിന് പിന്തുണ നൽകേണ്ടതായിരുന്നു സെഷനുകൾ и ഇടപാടുകൾ. etcd ക്കായി, പ്രോട്ടോക്കോളിൻ്റെ ഏറ്റവും പുതിയ പതിപ്പിനെ പിന്തുണയ്ക്കുന്ന ഒരു പൂർണ്ണമായ ലൈബ്രറി കണ്ടെത്തിയില്ല, അതിനാൽ ഞങ്ങൾ ലളിതമായി സൃഷ്ടിച്ച grpc ക്ലയൻ്റ്.

ZooKeeper C++ ലൈബ്രറിയുടെ അസിൻക്രണസ് ഇൻ്റർഫേസിൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ട്, ഒരു അസിൻക്രണസ് ഇൻ്റർഫേസും നടപ്പിലാക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു. ZooKeeper C++ ഇതിനായി ഭാവി/വാഗ്ദാന പ്രാകൃതങ്ങൾ ഉപയോഗിക്കുന്നു. STL ൽ, നിർഭാഗ്യവശാൽ, അവർ വളരെ എളിമയോടെ നടപ്പിലാക്കുന്നു. ഉദാഹരണത്തിന്, ഇല്ല പിന്നെ രീതി, പാസ്സായ ഫംഗ്‌ഷൻ ലഭ്യമാകുമ്പോൾ അത് ഭാവിയുടെ ഫലത്തിലേക്ക് പ്രയോഗിക്കുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ഫലം ഞങ്ങളുടെ ലൈബ്രറിയുടെ ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിന് അത്തരമൊരു രീതി ആവശ്യമാണ്. ഉപഭോക്താവിൻ്റെ അഭ്യർത്ഥന പ്രകാരം ഞങ്ങൾക്ക് ബൂസ്റ്റ് പോലുള്ള കനത്ത മൂന്നാം കക്ഷി ലൈബ്രറികൾ ഉപയോഗിക്കാൻ കഴിയാത്തതിനാൽ ഈ പ്രശ്‌നം പരിഹരിക്കുന്നതിന്, ഞങ്ങളുടെ സ്വന്തം ലളിതമായ ത്രെഡ് പൂൾ നടപ്പിലാക്കേണ്ടതുണ്ട്.

ഞങ്ങളുടെ അന്നത്തെ നടപ്പാക്കൽ ഇതുപോലെയാണ് പ്രവർത്തിക്കുന്നത്. വിളിക്കുമ്പോൾ, ഒരു അധിക വാഗ്ദാന/ഭാവി ജോഡി സൃഷ്ടിക്കപ്പെടുന്നു. പുതിയ ഭാവി തിരികെ നൽകി, പാസാക്കിയത് അനുബന്ധ ഫംഗ്ഷനും ക്യൂവിൽ ഒരു അധിക വാഗ്ദാനവും സഹിതം സ്ഥാപിക്കുന്നു. പൂളിൽ നിന്നുള്ള ഒരു ത്രെഡ് ക്യൂവിൽ നിന്ന് നിരവധി ഫ്യൂച്ചറുകൾ തിരഞ്ഞെടുത്ത് വെയിറ്റ്_ഫോർ ഉപയോഗിച്ച് വോട്ടെടുപ്പ് നടത്തുന്നു. ഒരു ഫലം ലഭ്യമാകുമ്പോൾ, അനുബന്ധ ഫംഗ്‌ഷൻ വിളിക്കുകയും അതിൻ്റെ റിട്ടേൺ മൂല്യം വാഗ്ദാനത്തിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു.

etcd, കോൺസൽ എന്നിവയിലേക്കുള്ള ചോദ്യങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യാൻ ഞങ്ങൾ ഇതേ ത്രെഡ് പൂൾ ഉപയോഗിച്ചു. ഇതിനർത്ഥം അടിസ്ഥാന ലൈബ്രറികൾ ഒന്നിലധികം വ്യത്യസ്ത ത്രെഡുകൾ വഴി ആക്സസ് ചെയ്യാൻ കഴിയും എന്നാണ്. ppconsul ത്രെഡ് സുരക്ഷിതമല്ല, അതിനാൽ അതിലേക്കുള്ള കോളുകൾ ലോക്കുകൾ ഉപയോഗിച്ച് പരിരക്ഷിച്ചിരിക്കുന്നു.
നിങ്ങൾക്ക് ഒന്നിലധികം ത്രെഡുകളിൽ നിന്ന് grpc ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും, എന്നാൽ സൂക്ഷ്മതകളുണ്ട്. etcd വാച്ചുകൾ grpc സ്ട്രീമുകൾ വഴിയാണ് നടപ്പിലാക്കുന്നത്. ഒരു പ്രത്യേക തരത്തിലുള്ള സന്ദേശങ്ങൾക്കുള്ള ദ്വിദിശ ചാനലുകളാണ് ഇവ. എല്ലാ വാച്ചുകൾക്കുമായി ഒരൊറ്റ ത്രെഡും ഇൻകമിംഗ് സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്ന ഒരൊറ്റ ത്രെഡും ലൈബ്രറി സൃഷ്ടിക്കുന്നു. അതിനാൽ സ്ട്രീം ചെയ്യുന്നതിനുള്ള സമാന്തര എഴുത്തുകൾ grpc നിരോധിക്കുന്നു. ഇതിനർത്ഥം ഒരു വാച്ച് ആരംഭിക്കുമ്പോഴോ ഇല്ലാതാക്കുമ്പോഴോ, അടുത്തത് അയയ്‌ക്കുന്നതിന് മുമ്പ് മുമ്പത്തെ അഭ്യർത്ഥന അയയ്‌ക്കുന്നത് വരെ നിങ്ങൾ കാത്തിരിക്കണം. ഞങ്ങൾ സമന്വയത്തിനായി ഉപയോഗിക്കുന്നു സോപാധിക വേരിയബിളുകൾ.

ഫലം

സ്വയം കാണുക: liboffkv.

ഞങ്ങളുടെ ടീം: റെയ്ഡ് റൊമാനോവ്, ഇവാൻ ഗ്ലുഷെങ്കോവ്, ദിമിത്രി കമൽഡിനോവ്, വിക്ടർ ക്രാപിവെൻസ്കി, വിറ്റാലി ഇവാനിൻ.

അവലംബം: www.habr.com