PHP ബാക്കെൻഡ് റെഡിസ് സ്ട്രീംസ് ബസിലേക്ക് മാറ്റുകയും ഒരു ഫ്രെയിംവർക്ക്-സ്വതന്ത്ര ലൈബ്രറി തിരഞ്ഞെടുക്കുകയും ചെയ്യുന്നു

മുൻവാചകം

ഞാൻ ഒരു ഹോബിയായി പ്രവർത്തിപ്പിക്കുന്ന എന്റെ വെബ്‌സൈറ്റ്, രസകരമായ ഹോം പേജുകളും വ്യക്തിഗത സൈറ്റുകളും ഹോസ്റ്റ് ചെയ്യുന്നതിനാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. എന്റെ പ്രോഗ്രാമിംഗ് യാത്രയുടെ തുടക്കത്തിൽ തന്നെ ഈ വിഷയം എനിക്ക് താൽപ്പര്യമുണ്ടാക്കാൻ തുടങ്ങി; തങ്ങളെക്കുറിച്ചും അവരുടെ ഹോബികളെക്കുറിച്ചും പ്രോജക്റ്റുകളെക്കുറിച്ചും എഴുതുന്ന മികച്ച പ്രൊഫഷണലുകളെ കണ്ടെത്തുന്നതിൽ ആ നിമിഷം ഞാൻ ആകർഷിച്ചു. അവ എനിക്കായി കണ്ടെത്തുന്ന ശീലം ഇന്നും നിലനിൽക്കുന്നു: മിക്കവാറും എല്ലാ വാണിജ്യ സൈറ്റുകളിലും, വളരെ വാണിജ്യപരമായ സൈറ്റുകളിലും, രചയിതാക്കൾക്കുള്ള ലിങ്കുകൾക്കായി ഞാൻ അടിക്കുറിപ്പിൽ നോക്കുന്നത് തുടരുന്നു.

ആശയം നടപ്പിലാക്കൽ

ആദ്യ പതിപ്പ് എന്റെ സ്വകാര്യ വെബ്‌സൈറ്റിലെ ഒരു html പേജ് മാത്രമായിരുന്നു, അവിടെ ഞാൻ ഒപ്പുകളുള്ള ലിങ്കുകൾ ഒരു ul ലിസ്റ്റിലേക്ക് ഇട്ടു. ഒരു നിശ്ചിത കാലയളവിൽ 20 പേജുകൾ ടൈപ്പ് ചെയ്തതിനാൽ, ഇത് വളരെ ഫലപ്രദമല്ലെന്ന് ഞാൻ ചിന്തിക്കാൻ തുടങ്ങി, ഈ പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യാൻ ശ്രമിക്കാൻ തീരുമാനിച്ചു. സ്റ്റാക്ക്ഓവർഫ്ലോയിൽ, പലരും അവരുടെ പ്രൊഫൈലുകളിൽ സൈറ്റുകൾ സൂചിപ്പിക്കുന്നത് ഞാൻ ശ്രദ്ധിച്ചു, അതിനാൽ ഞാൻ php-ൽ ഒരു പാഴ്സർ എഴുതി, ആദ്യത്തേതിൽ നിന്ന് ആരംഭിച്ച് പ്രൊഫൈലുകളിലൂടെ കടന്നുപോയി (ഇന്ന് വരെ SO-യിലെ വിലാസങ്ങൾ ഇതുപോലെയാണ്: `/users/1` ), ആവശ്യമുള്ള ടാഗിൽ നിന്ന് ലിങ്കുകൾ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്‌ത് അത് SQLite-ൽ ചേർത്തു.

ഇതിനെ രണ്ടാമത്തെ പതിപ്പ് എന്ന് വിളിക്കാം: ഒരു SQLite പട്ടികയിലെ പതിനായിരക്കണക്കിന് URL-കളുടെ ഒരു ശേഖരം, അത് HTML-ലെ സ്റ്റാറ്റിക് ലിസ്റ്റ് മാറ്റിസ്ഥാപിച്ചു. ഈ ലിസ്റ്റിൽ ഞാൻ ഒരു ലളിതമായ തിരയൽ നടത്തി. കാരണം URL-കൾ മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ, തുടർന്ന് തിരയൽ അവയെ അടിസ്ഥാനമാക്കിയുള്ളതായിരുന്നു.

ഈ ഘട്ടത്തിൽ ഞാൻ പ്രൊജക്റ്റ് ഉപേക്ഷിച്ച് വളരെക്കാലത്തിന് ശേഷം അതിലേക്ക് മടങ്ങി. ഈ ഘട്ടത്തിൽ, എന്റെ പ്രവൃത്തി പരിചയം ഇതിനകം മൂന്ന് വർഷത്തിലേറെയായിരുന്നു, എനിക്ക് കൂടുതൽ ഗൗരവമുള്ള എന്തെങ്കിലും ചെയ്യാൻ കഴിയുമെന്ന് എനിക്ക് തോന്നി. കൂടാതെ, താരതമ്യേന പുതിയ സാങ്കേതികവിദ്യകളിൽ പ്രാവീണ്യം നേടാനുള്ള വലിയ ആഗ്രഹമുണ്ടായിരുന്നു.

ആധുനിക പതിപ്പ്

പദ്ധതി ഡോക്കറിൽ വിന്യസിച്ചു, ഡാറ്റാബേസ് മോംഗോഡിബിയിലേക്ക് മാറ്റി, അടുത്തിടെ റാഡിഷ് ചേർത്തു, ഇത് ആദ്യം കാഷിംഗിനായി മാത്രമായിരുന്നു. PHP മൈക്രോഫ്രെയിംവർക്കുകളിൽ ഒന്ന് അടിസ്ഥാനമായി ഉപയോഗിക്കുന്നു.

പ്രശ്നം

ഇനിപ്പറയുന്നവ സമന്വയിപ്പിക്കുന്ന ഒരു കൺസോൾ കമാൻഡ് വഴി പുതിയ സൈറ്റുകൾ ചേർക്കുന്നു:

• URL പ്രകാരം ഉള്ളടക്കം ഡൗൺലോഡ് ചെയ്യുന്നു
• HTTPS ലഭ്യമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഫ്ലാഗ് സജ്ജീകരിക്കുന്നു
• വെബ്സൈറ്റിന്റെ സാരാംശം സംരക്ഷിക്കുന്നു
• ഉറവിട HTML ഉം തലക്കെട്ടുകളും "ഇൻഡക്സിംഗ്" ചരിത്രത്തിൽ സംരക്ഷിച്ചിരിക്കുന്നു
• ഉള്ളടക്കം പാഴ്‌സ് ചെയ്യുന്നു, ശീർഷകവും വിവരണവും വേർതിരിച്ചെടുക്കുന്നു
• ഒരു പ്രത്യേക ശേഖരത്തിലേക്ക് ഡാറ്റ സംരക്ഷിക്കുന്നു

സൈറ്റുകൾ സംഭരിക്കാനും അവ ഒരു ലിസ്റ്റിൽ പ്രദർശിപ്പിക്കാനും ഇത് മതിയാകും:

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

പൊതുവേ, തീർച്ചയായും, എല്ലാം സമന്വയിപ്പിച്ച് ചെയ്യാൻ കഴിയും, കൂടാതെ വെബ് രീതിയിൽ നിങ്ങൾക്ക് URL സംരക്ഷിക്കാൻ കഴിയും, അതുവഴി ഭയങ്കരമായ ഡെമൺ ലിസ്റ്റിൽ നിന്നുള്ള URL-കൾക്കായുള്ള എല്ലാ ജോലികളും ചെയ്യുന്നു. എന്നിട്ടും, ഇവിടെ പോലും "ക്യൂ" എന്ന വാക്ക് സ്വയം സൂചിപ്പിക്കുന്നു. ഒരു ക്യൂ നടപ്പിലാക്കുകയാണെങ്കിൽ, എല്ലാ ജോലികളും വിഭജിച്ച് കുറഞ്ഞത് അസമന്വിതമായി നിർവഹിക്കാൻ കഴിയും.

തീരുമാനം

എല്ലാ ജോലികളും പ്രോസസ്സ് ചെയ്യുന്നതിനായി ക്യൂകൾ നടപ്പിലാക്കുകയും ഇവന്റ്-ഡ്രൈവ് സിസ്റ്റം സൃഷ്ടിക്കുകയും ചെയ്യുക. വളരെക്കാലമായി റെഡിസ് സ്ട്രീമുകൾ പരീക്ഷിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

PHP-യിൽ Redis സ്ട്രീമുകൾ ഉപയോഗിക്കുന്നു

കാരണം എന്റെ ചട്ടക്കൂട് സിംഫണി, ലാറവെൽ, യി എന്നീ മൂന്ന് ഭീമൻമാരിൽ ഒന്നല്ലാത്തതിനാൽ, ഒരു സ്വതന്ത്ര ലൈബ്രറി കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. പക്ഷേ, അത് മാറിയതുപോലെ (ആദ്യ പരീക്ഷയിൽ), വ്യക്തിഗത ഗുരുതരമായ ലൈബ്രറികൾ കണ്ടെത്തുന്നത് അസാധ്യമാണ്. ക്യൂകളുമായി ബന്ധപ്പെട്ട എല്ലാം ഒന്നുകിൽ അഞ്ച് വർഷം മുമ്പ് 3 കമ്മിറ്റുകളിൽ നിന്നുള്ള ഒരു പ്രോജക്റ്റ് ആണ്, അല്ലെങ്കിൽ ചട്ടക്കൂടുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.

വ്യക്തിഗത ഉപയോഗപ്രദമായ ഘടകങ്ങളുടെ വിതരണക്കാരൻ എന്ന നിലയിൽ സിംഫോണിയെക്കുറിച്ച് ഞാൻ ധാരാളം കേട്ടിട്ടുണ്ട്, അവയിൽ ചിലത് ഞാൻ ഇതിനകം ഉപയോഗിക്കുന്നു. കൂടാതെ, Laravel-ൽ നിന്നുള്ള ചില കാര്യങ്ങളും ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്, അവയുടെ ORM, ചട്ടക്കൂടിന്റെ സാന്നിധ്യമില്ലാതെ.

സിംഫണി/മെസഞ്ചർ

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

ഔദ്യോഗിക സൈറ്റിലെ ഡോക്യുമെന്റേഷൻ വളരെ വിശദമായിരുന്നു, എന്നാൽ സിംഫണിക്ക് അവരുടെ പ്രിയപ്പെട്ട YML ഉപയോഗിച്ചും സിംഫണിസ്റ്റ് അല്ലാത്തവർക്കായി മറ്റ് മാജിക് രീതികൾ ഉപയോഗിച്ചും മാത്രമാണ് സമാരംഭം വിവരിച്ചത്. ഇൻസ്റ്റാളേഷൻ പ്രക്രിയയിൽ എനിക്ക് താൽപ്പര്യമില്ലായിരുന്നു, പ്രത്യേകിച്ച് പുതുവത്സര അവധിക്കാലത്ത്. പക്ഷേ, അപ്രതീക്ഷിതമായി വളരെക്കാലമായി എനിക്ക് ഇത് ചെയ്യേണ്ടിവന്നു.

സിംഫോണി സ്രോതസ്സുകൾ ഉപയോഗിച്ച് ഒരു സിസ്റ്റം എങ്ങനെ തൽക്ഷണം ചെയ്യാമെന്ന് കണ്ടുപിടിക്കാൻ ശ്രമിക്കുന്നതും കർശനമായ സമയപരിധിക്കുള്ള ഏറ്റവും നിസ്സാരമായ ജോലിയല്ല:

ഇതെല്ലാം ആഴ്ന്നിറങ്ങി, കൈകൊണ്ട് എന്തെങ്കിലും ചെയ്യാൻ ശ്രമിച്ചപ്പോൾ, ഞാൻ ഒരുതരം ക്രച്ചസ് ചെയ്യുന്നു എന്ന നിഗമനത്തിലെത്തി, മറ്റെന്തെങ്കിലും പരീക്ഷിക്കാൻ തീരുമാനിച്ചു.

പ്രകാശിതം/ക്യൂ

ഈ ലൈബ്രറി ലാറവെൽ ഇൻഫ്രാസ്ട്രക്ചറുമായും മറ്റ് ഒരു കൂട്ടം ഡിപൻഡൻസികളുമായും കർശനമായി ബന്ധപ്പെട്ടിരിക്കുന്നുവെന്ന് മനസ്സിലായി, അതിനാൽ ഞാൻ അതിൽ കൂടുതൽ സമയം ചെലവഴിച്ചില്ല: ഞാൻ അത് ഇൻസ്റ്റാൾ ചെയ്തു, നോക്കി, ഡിപൻഡൻസികൾ കണ്ടു, ഇല്ലാതാക്കി.

yiisoft/yii2-ക്യൂ

ശരി, ഇവിടെ ഇത് ഉടൻ തന്നെ പേരിൽ നിന്ന് അനുമാനിക്കപ്പെട്ടു, വീണ്ടും, Yii2 ലേക്ക് ഒരു കർശനമായ കണക്ഷൻ. എനിക്ക് ഈ ലൈബ്രറി ഉപയോഗിക്കേണ്ടിവന്നു, അത് മോശമായിരുന്നില്ല, പക്ഷേ ഇത് പൂർണ്ണമായും Yii2-നെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന വസ്തുതയെക്കുറിച്ച് ഞാൻ ചിന്തിച്ചില്ല.

ബാക്കിയുള്ളവ

GitHub-ൽ ഞാൻ കണ്ടെത്തിയ മറ്റെല്ലാം വിശ്വസനീയമല്ലാത്തതും കാലഹരണപ്പെട്ടതും നക്ഷത്രങ്ങളും ഫോർക്കുകളും ധാരാളം കമ്മിറ്റുകളും ഇല്ലാത്തതുമായ പ്രോജക്റ്റുകളാണ്.

സിംഫണി/മെസഞ്ചർ, സാങ്കേതിക വിശദാംശങ്ങൾ എന്നതിലേക്ക് മടങ്ങുക

എനിക്ക് ഈ ലൈബ്രറി കണ്ടുപിടിക്കേണ്ടി വന്നു, കുറച്ച് സമയം ചിലവഴിച്ചതിന് ശേഷം എനിക്ക് കഴിഞ്ഞു. എല്ലാം തികച്ചും സംക്ഷിപ്തവും ലളിതവുമാണെന്ന് ഇത് മാറി. ബസ് തൽക്ഷണം ചെയ്യാൻ, ഞാൻ ഒരു ചെറിയ ഫാക്ടറി ഉണ്ടാക്കി, കാരണം... എനിക്ക് നിരവധി ടയറുകളും വ്യത്യസ്ത ഹാൻഡ്‌ലറുകളും ഉണ്ടായിരിക്കണം.

ഏതാനും ഘട്ടങ്ങൾ മാത്രം:

• ഞങ്ങൾ മെസേജ് ഹാൻഡ്‌ലറുകൾ സൃഷ്ടിക്കുന്നു, അത് ലളിതമായി വിളിക്കാവുന്നതാണ്
• ഞങ്ങൾ അവയെ HandlerDescriptor-ൽ പൊതിയുന്നു (ലൈബ്രറിയിൽ നിന്നുള്ള ക്ലാസ്)
• ഞങ്ങൾ ഈ "ഡിസ്ക്രിപ്റ്ററുകൾ" ഒരു HandlersLocator ഉദാഹരണത്തിൽ പൊതിയുന്നു
• MessageBus ഉദാഹരണത്തിലേക്ക് HandlersLocator ചേർക്കുന്നു
• SendersLocator-ലേക്ക് ഞങ്ങൾ ഒരു സെറ്റ് `SenderInterface` കൈമാറുന്നു, എന്റെ കാര്യത്തിൽ, വ്യക്തമായ രീതിയിൽ ക്രമീകരിച്ചിരിക്കുന്ന `റെഡിസ്‌ട്രാൻസ്‌പോർട്ട്' ക്ലാസുകളുടെ സന്ദർഭങ്ങളിൽ
• MessageBus ഉദാഹരണത്തിലേക്ക് SendersLocator ചേർക്കുന്നു

MessageBus-ന് ഒരു `->ഡിസ്‌പാച്ച്()` രീതിയുണ്ട്, അത് HandlersLocator-ൽ ഉചിതമായ ഹാൻഡ്‌ലറുകളെ കണ്ടെത്തി അവർക്ക് സന്ദേശം കൈമാറുന്നു, ബസ് (റെഡിസ് സ്ട്രീമുകൾ) വഴി അയയ്‌ക്കുന്നതിന് അനുബന്ധ `സെൻഡർ ഇന്റർഫേസ്` ഉപയോഗിച്ച്.

കണ്ടെയ്നർ കോൺഫിഗറേഷനിൽ (ഈ സാഹചര്യത്തിൽ php-di), ഈ മുഴുവൻ ബണ്ടിലും ഇതുപോലെ കോൺഫിഗർ ചെയ്യാം:

        CONTAINER_REDIS_TRANSPORT_SECRET => function (ContainerInterface $c) {
            return new RedisTransport(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_SECRET),
                $c->get(CONTAINER_SERIALIZER))
            ;
        },
        CONTAINER_REDIS_TRANSPORT_LOG => function (ContainerInterface $c) {
            return new RedisTransport(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_LOG),
                $c->get(CONTAINER_SERIALIZER))
            ;
        },
        CONTAINER_REDIS_STREAM_RECEIVER_SECRET => function (ContainerInterface $c) {
            return new RedisReceiver(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_SECRET),
                $c->get(CONTAINER_SERIALIZER)
            );
        },
        CONTAINER_REDIS_STREAM_RECEIVER_LOG => function (ContainerInterface $c) {
            return new RedisReceiver(
                $c->get(CONTAINER_REDIS_STREAM_CONNECTION_LOG),
                $c->get(CONTAINER_SERIALIZER)
            );
        },
        CONTAINER_REDIS_STREAM_BUS => function (ContainerInterface $c) {
            $sendersLocator = new SendersLocator([
                AppMessagesSecretJsonMessages::class => [CONTAINER_REDIS_TRANSPORT_SECRET],
                AppMessagesDaemonLogMessage::class => [CONTAINER_REDIS_TRANSPORT_LOG],
            ], $c);
            $middleware[] = new SendMessageMiddleware($sendersLocator);

            return new MessageBus($middleware);
        },
        CONTAINER_REDIS_STREAM_CONNECTION_SECRET => function (ContainerInterface $c) {
            $host = 'bu-02-redis';
            $port = 6379;
            $dsn = "redis://$host:$port";
            $options = [
                'stream' => 'secret',
                'group' => 'default',
                'consumer' => 'default',
            ];

            return Connection::fromDsn($dsn, $options);
        },
        CONTAINER_REDIS_STREAM_CONNECTION_LOG => function (ContainerInterface $c) {
            $host = 'bu-02-redis';
            $port = 6379;
            $dsn = "redis://$host:$port";
            $options = [
                'stream' => 'log',
                'group' => 'default',
                'consumer' => 'default',
            ];

            return Connection::fromDsn($dsn, $options);
        },

SendersLocator-ൽ ഞങ്ങൾ രണ്ട് വ്യത്യസ്ത സന്ദേശങ്ങൾക്കായി വ്യത്യസ്ത “ട്രാൻസ്‌പോർട്ടുകൾ” നൽകിയിട്ടുണ്ടെന്ന് ഇവിടെ നിങ്ങൾക്ക് കാണാൻ കഴിയും, അവയിൽ ഓരോന്നിനും അനുബന്ധ സ്ട്രീമുകളുമായി അതിന്റേതായ കണക്ഷനുണ്ട്.

ഇനിപ്പറയുന്ന ബസ് ഉപയോഗിച്ച് പരസ്പരം ആശയവിനിമയം നടത്തുന്ന മൂന്ന് ഡെമണുകളുടെ ഒരു ആപ്ലിക്കേഷൻ പ്രകടമാക്കുന്ന ഒരു പ്രത്യേക ഡെമോ പ്രോജക്റ്റ് ഞാൻ ഉണ്ടാക്കി: https://github.com/backend-university/products/tree/master/products/02-redis-streams-bus.

എന്നാൽ ഒരു ഉപഭോക്താവിനെ എങ്ങനെ ക്രമീകരിക്കാമെന്ന് ഞാൻ കാണിച്ചുതരാം:

use AppMessagesDaemonLogMessage;
use SymfonyComponentMessengerHandlerHandlerDescriptor;
use SymfonyComponentMessengerHandlerHandlersLocator;
use SymfonyComponentMessengerMessageBus;
use SymfonyComponentMessengerMiddlewareHandleMessageMiddleware;
use SymfonyComponentMessengerMiddlewareSendMessageMiddleware;
use SymfonyComponentMessengerTransportSenderSendersLocator;

require_once __DIR__ . '/../vendor/autoload.php';
/** @var PsrContainerContainerInterface $container */
$container = require_once('config/container.php');

$handlers = [
    DaemonLogMessage::class => [
        new HandlerDescriptor(
            function (DaemonLogMessage $m) {
                error_log('DaemonLogHandler: message handled: / ' . $m->getMessage());
            },
            ['from_transport' => CONTAINER_REDIS_TRANSPORT_LOG]
        )
    ],
];
$middleware = [];
$middleware[] = new HandleMessageMiddleware(new HandlersLocator($handlers));
$sendersLocator = new SendersLocator(['*' => [CONTAINER_REDIS_TRANSPORT_LOG]], $container);
$middleware[] = new SendMessageMiddleware($sendersLocator);

$bus = new MessageBus($middleware);
$receivers = [
    CONTAINER_REDIS_TRANSPORT_LOG => $container->get(CONTAINER_REDIS_STREAM_RECEIVER_LOG),
];
$w = new SymfonyComponentMessengerWorker($receivers, $bus, $container->get(CONTAINER_EVENT_DISPATCHER));
$w->run();

ഒരു ആപ്ലിക്കേഷനിൽ ഈ ഇൻഫ്രാസ്ട്രക്ചർ ഉപയോഗിക്കുന്നു

എന്റെ ബാക്കെൻഡിൽ ബസ് നടപ്പിലാക്കിയ ശേഷം, ഞാൻ പഴയ സിൻക്രണസ് കമാൻഡിൽ നിന്ന് വ്യക്തിഗത ഘട്ടങ്ങൾ വേർതിരിച്ച് പ്രത്യേക ഹാൻഡ്‌ലറുകൾ ഉണ്ടാക്കി, ഓരോരുത്തരും അവരവരുടെ കാര്യങ്ങൾ ചെയ്യുന്നു.

ഡാറ്റാബേസിലേക്ക് ഒരു പുതിയ സൈറ്റ് ചേർക്കുന്നതിനുള്ള പൈപ്പ്ലൈൻ ഇതുപോലെ കാണപ്പെട്ടു:

അതിനുശേഷം ഉടൻ തന്നെ, പുതിയ പ്രവർത്തനം ചേർക്കുന്നത് എനിക്ക് വളരെ എളുപ്പമായി. കാരണം ഈ പ്രക്രിയയ്ക്ക് യഥാർത്ഥ ഉള്ളടക്കവും ആവശ്യമാണ്, തുടർന്ന് WebsiteIndexHistoryPersistor പോലെയുള്ള RSS ലിങ്ക് എക്‌സ്‌ട്രാക്റ്റർ ഹാൻഡ്‌ലർ "ഉള്ളടക്കം/HtmlContent" സന്ദേശം സബ്‌സ്‌ക്രൈബുചെയ്യുകയും അത് പ്രോസസ്സ് ചെയ്യുകയും ആവശ്യമുള്ള സന്ദേശം അതിന്റെ പൈപ്പ്ലൈനിലൂടെ കൂടുതൽ കൈമാറുകയും ചെയ്യുന്നു.

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

ഇപ്പോൾ, ഡാറ്റാബേസിൽ നിന്ന് തിരഞ്ഞെടുക്കുന്നതിനുപകരം, പെർസിസ്റ്റർ ഉൾപ്പെടുത്തിയതിന് ശേഷം ആവശ്യമായ ഐഡികൾ താൽപ്പര്യമുള്ള എല്ലാ ഹാൻഡ്‌ലർമാർക്കും ബസ് വഴി കൈമാറുന്നു.

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