Basisprincipes van het werken met zmq in Python, het creëren van een eenvoudige key/value opslag

Inleiding

Laten we een voorbeeld van een eenvoudige key/value-opslag bespreken, zoals memcache. Het is eenvoudig opgezet: gegevens worden opgeslagen in het geheugen, in de structuur van een hashmap. Toegang tot deze gegevens gebeurt via een tcp-socket. In Python is een hashmap een gewone dict. We gebruiken zeromq voor de toegang.

Instellingen

Om dit pakket in debian/ubuntu te installeren, hoef je alleen maar het volgende in de terminal in te voeren:
sudo apt-get install libzmq-dev
sudo pip install zmq

Code

Laten we een klasse schrijven voor onze server:
Het type dat we gebruiken voor de zmq-socket is REQ (REQuest, verzoek), we sturen een verzoek en wachten op een antwoord.
Om elke soort gegevens op te slaan en over het netwerk te verzenden, gebruiken we de standaardmodule pickle. Het 'protocol' van de werking is een tuple van drie waarden: (commando, sleutel, gegevens)

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'

Gebruik van

cache = SuperCacher()
cache.set('key', 'value')
cache.get('key')

Als huiswerkopdracht — verbeter de implementatie door de mogelijkheid toe te voegen om een adres/poort op te geven bij het maken van een instantie van de klasse.

Laten we nu de daemon schrijven. server.
Deze keer gebruiken we een REP-socket (REPly, antwoord) — we wachten op een verzoek en sturen een antwoord. We analyseren het verzoek en antwoorden met 'ok' in geval van schrijven, of met de gegevens / None in geval van lezen.

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()

Om alles samen te testen, starten we de server met het volgende commando:
python daemon.py

In een ander tabblad starten we python in de interactieve modus.

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

Oh wonder, het werkt! Je kunt nu met vertrouwen in je cv schrijven 'ontwikkeling van een key-value-opslag met het gebruik van het zmq-protocol'

Bron: habr.com