పైథాన్‌లో zmqతో పని చేసే ప్రాథమిక అంశాలు, సాధారణ కీ/విలువ స్టోర్‌ని సృష్టించడం

పరిచయం

మెమ్‌కాష్ వంటి సాధారణ కీ/విలువ నిల్వ యొక్క ఉదాహరణను చూద్దాం. ఇది సరళంగా రూపొందించబడింది - డేటా మెమరీలో, హ్యాష్‌మ్యాప్ నిర్మాణంలో నిల్వ చేయబడుతుంది. అవి tcp సాకెట్ ద్వారా యాక్సెస్ చేయబడతాయి. పైథాన్‌లో, హాష్‌మ్యాప్ అనేది సాధారణ శాసనం. యాక్సెస్ కోసం మేము zeromqని ఉపయోగిస్తాము.

సర్దుబాటు

ఈ ప్యాకేజీని debian/ubuntuలో ఇన్‌స్టాల్ చేయడానికి, కన్సోల్‌లో నమోదు చేయండి
sudo apt-get install libzmq-dev
sudo pip install zmq

కోడ్

మా సర్వర్‌తో పని చేయడానికి ఒక తరగతిని వ్రాద్దాం:
ఉపయోగించిన zmq సాకెట్ రకం REQ(అభ్యర్థన, అభ్యర్థన), మేము అభ్యర్థనను పంపుతాము మరియు ప్రతిస్పందన కోసం వేచి ఉంటాము.
నెట్‌వర్క్‌లో ఏదైనా రకమైన డేటాను నిల్వ చేయడానికి మరియు ప్రసారం చేయడానికి, మేము ప్రామాణిక పికిల్ మాడ్యూల్‌ని ఉపయోగిస్తాము. పని "ప్రోటోకాల్" అనేది మూడు విలువల టూపుల్: (కమాండ్, కీ, డేటా)

import zmq
import pickle

class SuperCacher:
    def __init__(self):
        context = zmq.Context()
        self.socket = context.socket(zmq.REQ)
        self.socket.connect('tcp://127.0.0.1:43000')

    def get(self, key):
        self.socket.send(pickle.dumps(('get', key, None)))
        return pickle.loads(self.socket.recv())

    def set(self, key, data):
        self.socket.send(pickle.dumps(('set', key, data)))
        return self.socket.recv() == b'ok'

ఉపయోగం

కాష్ = సూపర్ క్యాచర్()
cache.set('కీ', 'విలువ')
cache.get('కీ')

హోంవర్క్‌గా, తరగతి యొక్క ఉదాహరణను సృష్టించేటప్పుడు చిరునామా/పోర్ట్‌ను పేర్కొనే సామర్థ్యాన్ని జోడించడం ద్వారా అమలును మెరుగుపరచండి.

ఇప్పుడు సర్వర్‌నే వ్రాస్దాం.
ఈసారి సాకెట్ REP(ప్రత్యుత్తరం, ప్రతిస్పందన) ఉపయోగించబడుతుంది - మేము అభ్యర్థన కోసం వేచి ఉన్నాము, ప్రతిస్పందనను పంపుతున్నాము. మేము అభ్యర్థనను అన్వయించాము మరియు వ్రాసే సందర్భంలో 'సరే'తో ప్రతిస్పందిస్తాము లేదా చదివే సందర్భంలో డేటా / ఏదీ లేదు.

import pickle
import json
import zmq

def run_daemon():
    memory = {}

    context = zmq.Context()
    socket = context.socket(zmq.REP)
    socket.bind('tcp://127.0.0.1:43000')

    while True:
        try:
            command, key, data = pickle.loads(socket.recv())
            if command == 'set':
                memory[key] = data
                socket.send(b'ok')
            elif command == 'get':
                result = memory.get(key, None)
                socket.send(pickle.dumps(result))
        except Exception as e:
            print(e)

if __name__ == '__main__':
    run_daemon()

ప్రతిదీ కలిసి పరీక్షించడానికి, మేము ఆదేశంతో సర్వర్‌ను ప్రారంభిస్తాము
python daemon.py

తదుపరి ట్యాబ్‌లో, ఇంటరాక్టివ్ మోడ్‌లో పైథాన్‌ను ప్రారంభించండి.

>>> from lib import SuperCacher
>>> cache=SuperCacher()
>>> cache.set('key', 'value')
True
>>> cache.get('key')
'value'

ఓ అద్భుతం, ఇది పనిచేస్తుంది! ఇప్పుడు మీరు మీ రెజ్యూమ్‌లో “zmq ప్రోటోకాల్‌ని ఉపయోగించి కీ-విలువ నిల్వ అభివృద్ధి”ని సురక్షితంగా వ్రాయవచ్చు.

మూలం: www.habr.com