Communication inter-processus entre Ruby et Python (file d'attente de messages POSIX)

Aperçu

Quand je pensais à passer des données entre les démons ruby et python en utilisant redis (Pub / Sub) [^ Streams], j'ai entendu une voix céleste me dire qu'il serait plus facile d'utiliser la communication inter-processus (POSIX IPC), alors je l'ai essayé. Je l'ai essayé.

De plus, comme il fonctionnera cette fois sur le raspberry pi, nous envisageons une stratégie pour réduire au maximum le nombre de processus en raison de problèmes d'alimentation.

[^ Streams]: De redis5, il existe une fonctionnalité supplémentaire appelée Streams qui est plus fiable que la fonctionnalité Pub / Sub.

Qu'est-ce qu'une file d'attente de messages POSIX?

Une des communications inter-processus qui peut être utilisée via la fonction d'appel système / bibliothèque de POSIX. Protocole de communication asynchrone, comme une version super simplifiée d'un middleware de messagerie tel que Rabbit MQ, sans crainte de malentendu. Comme il est conforme à POSIX, il peut être facilement utilisé avec une simple API.

Veuillez vous référer à ce qui suit pour plus de détails.

https://linuxjm.osdn.jp/html/LDP_man-pages/man7/mq_overview.7.html

Le système au complet

• OS: Raspbian GNU/Linux 10 (buster)
• ruby: ruby 2.5.7p206 (2019-10-01 revision 67816) [armv7l-linux-eabihf] --Bibliothèque utilisée: posix-mqueue
  • https://github.com/sirupsen/posix-mqueue
• python: Python 2.7.16 --Bibliothèque utilisée: posix_ipc
  • https://pypi.org/project/posix_ipc/

Implémentation côté Ruby (côté expéditeur)

Peu importe lequel est envoyé / reçu, mais cette fois j'ai essayé Ruby en tant qu'expéditeur. J'ai utilisé posix-mqueue comme bibliothèque à utiliser. Très simple.

require 'posix/mqueue'
require 'json'

def main
  m = POSIX::Mqueue.new("/whatever", msgsize: 8192, maxmsg: 10)
  10.times do |i|
    m.send({ messsage: "hello python world #{i}" }.to_json)
    sleep 1
  end
  m.send ({ message: 'end'}.to_json)
ensure
  m.unlink if m
end

if __FILE__ == $PROGRAM_NAME
  main
end

Implémentation côté Python (côté récepteur)

C'est aussi horriblement simple. La bibliothèque utilisée est posix_ipc

# -*- coding: utf-8 -*-
import time
import posix_ipc
import json

def main () :
    mq = posix_ipc.MessageQueue("/whatever", posix_ipc.O_CREAT)
    while True:
        data = mq.receive()
        j = json.loads(data[0]) # ->  (message, priority)Reviens avec un taple
        print j
        if j.get('message') == "end":
            break

if __name__ == "__main__" : 
    main()

résultat

Il était sorti côté Python comme prévu!

$ python main.py 
{u'messsage': u'hello python world 0'}
{u'messsage': u'hello python world 1'}
{u'messsage': u'hello python world 2'}
{u'messsage': u'hello python world 3'}
{u'messsage': u'hello python world 4'}
{u'messsage': u'hello python world 5'}
{u'messsage': u'hello python world 6'}
{u'messsage': u'hello python world 7'}
{u'messsage': u'hello python world 8'}
{u'messsage': u'hello python world 9'}
{u'message': u'end'}

C'est une source simple, mais je l'ai postée sur github. https://github.com/y-amadatsu/posix-mq-with-raspberry-pi-os

De côté

D'ailleurs, si vous utilisez le message POSIX, la file d'attente des messages sera affichée sous / dev / mqueue. Il peut également être monté et utilisé avec "ls" ou "rm". Cette zone est très UNIX! C'est comme: détendu:

cat /dev/mqueue/whatever 
QSIZE:350        NOTIFY:0     SIGNO:0     NOTIFY_PID:0