Psycopg3 के साथ लंबे समय तक चलने वाले PostgreSQL अधिसूचना श्रोताओं में स्थिरता सुनिश्चित करना

लंबे समय तक चलने वाले PostgreSQL श्रोताओं में विश्वसनीय सूचनाएं सुनिश्चित करना

लंबे समय से चल रहे डेटाबेस कनेक्शन को संभालने के लिए पायथन और psycopg3 का उपयोग करके बैकएंड कार्यान्वयन

import psycopg
from psycopg import sql
import time
CONN_STR = "postgresql://user:password@localhost/dbname"
def listen_notifications():
    try:
        with psycopg.connect(CONN_STR, autocommit=True) as conn:
            listen_sql = sql.SQL("LISTEN {};").format(sql.Identifier("scheduler_test"))
            conn.execute(listen_sql)
            print("Listening for notifications...")
            gen = conn.notifies(timeout=5)
            for notification in gen:
                print("Received notification:", notification)
                perform_health_check(conn, listen_sql)
    except Exception as e:
        print("Error:", e)
def perform_health_check(conn, listen_sql):
    try:
        print("Performing health check...")
        conn.execute("SELECT 1")
        conn.execute(listen_sql)
    except Exception as e:
        print("Health check failed:", e)
if __name__ == "__main__":
    listen_notifications()

वैकल्पिक दृष्टिकोण: बढ़ी हुई प्रतिक्रिया के लिए एसिंक्रोनस psycopg3 का उपयोग करना

Python के asyncio और psycopg3 का उपयोग करके अतुल्यकालिक कार्यान्वयन

import asyncio
from psycopg import AsyncConnection, sql
CONN_STR = "postgresql://user:password@localhost/dbname"
async def listen_notifications():
    try:
        async with AsyncConnection.connect(CONN_STR, autocommit=True) as conn:
            listen_sql = sql.SQL("LISTEN {};").format(sql.Identifier("scheduler_test"))
            await conn.execute(listen_sql)
            print("Listening for notifications...")
            gen = conn.notifies(timeout=5)
            async for notification in gen:
                print("Received notification:", notification)
                await perform_health_check(conn, listen_sql)
    except Exception as e:
        print("Error:", e)
async def perform_health_check(conn, listen_sql):
    try:
        print("Performing health check...")
        await conn.execute("SELECT 1")
        await conn.execute(listen_sql)
    except Exception as e:
        print("Health check failed:", e)
if __name__ == "__main__":
    asyncio.run(listen_notifications())

मजबूती के लिए इकाई परीक्षण

यूनिटटेस्ट का उपयोग करके बैकएंड लॉजिक के लिए पायथन यूनिट परीक्षण

import unittest
from unittest.mock import patch, MagicMock
class TestNotificationListener(unittest.TestCase):
    @patch("psycopg.connect")
    def test_listen_notifications(self, mock_connect):
        mock_conn = MagicMock()
        mock_connect.return_value.__enter__.return_value = mock_conn
        mock_conn.notifies.return_value = iter(["test_notification"])
        listen_notifications()
        mock_conn.execute.assert_called_with("LISTEN scheduler_test;")
        mock_conn.notifies.assert_called_once()
if __name__ == "__main__":
    unittest.main()

PostgreSQL अधिसूचना श्रोताओं को प्रबंधित करने पर अक्सर पूछे जाने वाले प्रश्न

1. का उद्देश्य क्या है conn.notifies() psycopg3 में?
2. conn.notifies() इसका उपयोग PostgreSQL सर्वर द्वारा भेजी गई सूचनाओं को पुनः प्राप्त करने के लिए किया जाता है, जो अनुप्रयोगों में वास्तविक समय की घटना को संभालने में सक्षम बनाता है।
3. कर सकना LISTEN पुन:कनेक्शन के दौरान आदेश संदेश खो देते हैं?
4. नहीं, PostgreSQL सूचनाओं को बफ़र करता है, इसलिए पुन: कनेक्शन के दौरान संदेश नष्ट नहीं होते हैं। हालाँकि, का उचित प्रबंधन notifies निर्बाध प्रसंस्करण सुनिश्चित करने के लिए जनरेटर की आवश्यकता होती है।
5. मुझे क्यों उपयोग करना चाहिए? autocommit=True?
6. सेटिंग autocommit=True जैसे कनेक्शन को तुरंत कमांड लागू करने की अनुमति देता है LISTEN किसी स्पष्ट प्रतिबद्धता की प्रतीक्षा किए बिना, प्रतिक्रियाशीलता में सुधार करना।
7. मैं लंबी दौड़ के दौरान स्वास्थ्य जांच कैसे कर सकता हूं? notifies प्रक्रिया?
8. आप समय-समय पर हल्के प्रश्नों को निष्पादित कर सकते हैं जैसे SELECT 1 यह सुनिश्चित करने के लिए कि कनेक्शन उत्तरदायी बना रहे।
9. डेटाबेस कनेक्शन को साफ़ करने के लिए सर्वोत्तम प्रथाएँ क्या हैं?
10. ए का उपयोग करना with स्टेटमेंट या पायथन का संदर्भ प्रबंधक यह सुनिश्चित करता है कि संसाधन लीक से बचने के लिए कनेक्शन ठीक से बंद है।
11. मैं टाइमआउट अपवादों को कैसे संभालूं? conn.notifies()?
12. लपेटना conn.notifies() टाइमआउट अपवादों को पकड़ने और उन्हें शानदार ढंग से संभालने के लिए प्रयास-छोड़कर ब्लॉक में, जैसे लॉगिंग या पुनः प्रयास करके।
13. क्या psycopg3 सूचनाओं के लिए अतुल्यकालिक संचालन का समर्थन करता है?
14. हां, psycopg3 एक एसिंक्रोनस एपीआई प्रदान करता है AsyncConnection, जो गैर-अवरुद्ध, स्केलेबल अनुप्रयोगों के लिए आदर्श है।
15. यदि मैं इसे बंद न करूँ तो क्या होगा? notifies जेनरेटर?
16. जनरेटर को बंद करने में विफलता के परिणामस्वरूप मेमोरी लीक हो सकती है या संसाधन लटक सकते हैं, खासकर लंबे समय तक चलने वाली प्रक्रियाओं में।
17. क्या इस दौरान सूचनाएं छूट सकती हैं? pg_sleep() संचालन?
18. हाँ, यदि बफ़र नहीं किया गया तो नींद की अवधि के दौरान उत्पन्न सूचनाएं छूट सकती हैं, यही कारण है कि उचित प्रबंधन किया जा सकता है LISTEN आदेश महत्वपूर्ण है.
19. क्या एकाधिक सूचनाओं के लिए एक ही कनेक्शन का पुन: उपयोग करना सुरक्षित है?
20. हां, जब तक स्वास्थ्य जांच और उचित पुन: कनेक्शन प्रबंधित किया जाता है, उसी कनेक्शन का पुन: उपयोग कुशल और संसाधन-अनुकूल है।
21. मैं अपनी अधिसूचना प्रणाली की विश्वसनीयता का परीक्षण कैसे कर सकता हूँ?
22. जैसे पुस्तकालयों का उपयोग करके इकाई परीक्षण लिखें unittest.mock लाइव सर्वर पर निर्भर हुए बिना सूचनाओं और डेटाबेस व्यवहार का अनुकरण करना।

विश्वसनीय अधिसूचना सुनना सुनिश्चित करना

लंबे समय तक चलने वाली प्रक्रियाओं के लिए कनेक्शन स्वास्थ्य बनाए रखना निर्बाध संचालन के लिए आवश्यक है। psycopg3 जैसे टूल के साथ conn.सूचित करता है(), डेवलपर्स मजबूत अधिसूचना प्रणाली लागू कर सकते हैं। नियमित स्वास्थ्य जांच अनुत्तरदायी कनेक्शन से बचने में मदद करती है। उदाहरणों में आउटेज को रोकने के लिए लाइव अपडेट के लिए इन्वेंट्री सिस्टम की निगरानी करना शामिल है।

नोटिफ़िकेशन जेनरेटर को बंद करना और फिर से खोलना, हल्के SQL कमांड के साथ मिलकर, प्रदर्शन और विश्वसनीयता दोनों सुनिश्चित करता है। ये तकनीकें लॉजिस्टिक्स अपडेट से लेकर वित्तीय अलर्ट तक विभिन्न उपयोग के मामलों पर लागू होती हैं। ऐसी रणनीतियाँ महत्वपूर्ण अनुप्रयोगों को डाउनटाइम से बचाने में मदद करती हैं, जिससे एक निर्बाध उपयोगकर्ता अनुभव सुनिश्चित होता है। ⚡