Basisprincipes van het werken met zmq in Python, het creëren van een eenvoudige sleutel/waarde-opslag

Introductie

Laten we eens kijken naar een voorbeeld van een eenvoudige sleutel/waarde-opslag, zoals memcache. Het is eenvoudig ontworpen: de gegevens worden in het geheugen opgeslagen, in een hashmap-structuur. Ze zijn toegankelijk via een TCP-socket. In Python is hashmap een regulier dictaat. Voor toegang gebruiken we zeromq.

afstelling

Om dit pakket in debian/ubuntu te installeren, hoeft u alleen maar naar de console te gaan
sudo apt-get install libzmq-dev
sudo pip install zmq

code

Laten we een klasse schrijven om met onze server te werken:
Het gebruikte type zmq-socket is REQ(REQuest, request), we sturen een verzoek en wachten op een reactie.
Om elk type gegevens over het netwerk op te slaan en te verzenden, gebruiken we de standaard Pickle-module. Het werk “protocol” is een tupel van drie waarden: (opdracht, 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'

Gebruiken

cache = SuperCacher()
cache.set('sleutel', 'waarde')
cache.get('sleutel')

Verbeter als huiswerk de implementatie door de mogelijkheid toe te voegen om een ​​adres/poort op te geven bij het maken van een exemplaar van een klasse.

Laten we nu de server zelf schrijven.
Deze keer wordt de socket REP(REPly, response) gebruikt - we wachten op het verzoek en sturen een antwoord. We parseren het verzoek en reageren met 'ok' in het geval van schrijven, of met data / Geen in het 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 commando
python daemon.py

Start Python op het volgende tabblad in de interactieve modus.

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

Oh wonder, het werkt! Nu kunt u veilig in uw cv schrijven: “ontwikkeling van sleutelwaardeopslag met behulp van het zmq-protocol”

Bron: www.habr.com