പൈത്തണിൽ zmq ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന്റെ അടിസ്ഥാനങ്ങൾ, ഒരു ലളിതമായ കീ/മൂല്യം സ്റ്റോർ സൃഷ്ടിക്കുന്നു

ആമുഖം

മെംകാഷെ പോലെയുള്ള ഒരു ലളിതമായ കീ/മൂല്യ സംഭരണത്തിന്റെ ഒരു ഉദാഹരണം നോക്കാം. ഇത് ലളിതമായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു - ഡാറ്റ മെമ്മറിയിൽ, ഒരു ഹാഷ്‌മാപ്പ് ഘടനയിൽ സംഭരിച്ചിരിക്കുന്നു. ഒരു ടിസിപി സോക്കറ്റ് വഴിയാണ് അവ ആക്സസ് ചെയ്യുന്നത്. പൈത്തണിൽ, ഹാഷ്മാപ്പ് ഒരു സ്ഥിരം ആഖ്യാനമാണ്. പ്രവേശനത്തിനായി ഞങ്ങൾ zeromq ഉപയോഗിക്കും.

കമപ്പെടുത്തല്

ഈ പാക്കേജ് ഡെബിയൻ/ഉബുണ്ടുവിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ, കൺസോളിൽ നൽകുക
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'

ഉപയോഗിക്കുക

കാഷെ = SuperCacher()
cache.set('കീ', 'മൂല്യം')
cache.get('കീ')

ഗൃഹപാഠമെന്ന നിലയിൽ, ഒരു ക്ലാസിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കുമ്പോൾ ഒരു വിലാസം/പോർട്ട് വ്യക്തമാക്കാനുള്ള കഴിവ് ചേർത്ത് നടപ്പിലാക്കൽ മെച്ചപ്പെടുത്തുക.

ഇനി നമുക്ക് സെർവർ തന്നെ എഴുതാം.
ഈ സമയം സോക്കറ്റ് REP (REPly, പ്രതികരണം) ഉപയോഗിക്കുന്നു - ഞങ്ങൾ അഭ്യർത്ഥനയ്ക്കായി കാത്തിരിക്കുകയാണ്, ഒരു പ്രതികരണം അയയ്ക്കുന്നു. ഞങ്ങൾ അഭ്യർത്ഥന പാഴ്‌സ് ചെയ്‌ത് എഴുതുന്ന കാര്യത്തിൽ 'ശരി' എന്നോ അല്ലെങ്കിൽ വായിക്കുന്ന കാര്യത്തിൽ ഡാറ്റ / ഒന്നുമില്ല എന്നോ മറുപടി നൽകും.

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