પાયથોનમાં zmq સાથે કામ કરવાની મૂળભૂત બાબતો, એક સરળ કી/વેલ્યુ સ્ટોર બનાવીને

પરિચય

ચાલો એક સરળ કી/વેલ્યુ સ્ટોરેજનું ઉદાહરણ જોઈએ, જેમ કે મેમકેશ. તે સરળ રીતે ડિઝાઇન કરવામાં આવ્યું છે - ડેટા હેશમેપ સ્ટ્રક્ચરમાં મેમરીમાં સંગ્રહિત થાય છે. તેઓને tcp સોકેટ દ્વારા એક્સેસ કરવામાં આવે છે. પાયથોનમાં, હેશમેપ એ નિયમિત ડિક્ટ છે. એક્સેસ માટે આપણે 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'

ઉપયોગ કરો

cache = સુપરકેચર()
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