Code en Python, communique dans Node.js et Socket.IO, présent en HTML

Vous avez un script python diagnosis.py qui génère en temps réel de l'événement base de données. À l'aide de Node.js vous pouvez lancer aussi un enfant de processus de capture et de sa sortie et ensuite à l'aide d'une Douille.IO émettent que pour le client et de le présenter à l'aide de HTML.

Serveur

var util  = require('util'),
    spawn = require('child_process').spawn,
    ls    = spawn('python', ['diagnosis.py']);

var app = require('http').createServer(handler)
  , io = require('socket.io').listen(app)
  , fs = require('fs')

app.listen(80);

function handler (req, res) {
  fs.readFile(__dirname + '/index.html',
  function (err, data) {
    if (err) {
      res.writeHead(500);
      return res.end('Error loading index.html');
    }

    res.writeHead(200);
    res.end(data);
  });
}

io.sockets.on('connection', function (socket) {
    ls.stdout.on('data', function (gdata) {
      socket.emit('news', gdata.toString());
    });
});

Client

<html>
    <head>
        <script src="/socket.io/socket.io.js"></script>
        <script>
          var d = "";
          var socket = io.connect('http://localhost');
          socket.on('news', function (data) {
            d += data;
            document.getElementById('data').innerHTML = d;
            console.log(data);
          });
        </script>
    </head>
    <body>
        <div id="data"></div>
    </body>
</html>

Question

C'est super et tout, mais si vous êtes à la recherche pour le même HTML-Node.js pouvoir de communication de cette Prise.IO fournit, mais plutôt entre Node.js et Python? Comment voudriez-vous faire cela? Il n'y a pas de serveur web, de sorte Socket.IO ne fait pas beaucoup de sens et de communication de nu TCP n'est pas la même alimentation/de l'élégance. Comment puis-je obtenir communication full duplex entre Node.js et Python?

Code en Python, communique dans Node.js et Socket.IO, présent en HTML

Mise à jour j'ai répondu à ma propre question, mais je suis ouvert à une approche alternative. RPC n'est pas tout à fait faire ce que je veux.

source d'informationauteur melhosseiny

7

Apache Épargne est assez impressionnant façon d'écrire le code RPC entre toutes les langues principales. Vous écrivez un générique d'Aubaines spec déclarer les types et les services, puis le générateur de code crée des liaisons pour les langues que vous souhaitez. Vous pouvez avoir des api pour l'appel de méthodes entre votre nœud et python bases de code.

Sur un plus générique faible niveau de l'approche, ZeroMQ est un message de la file d'attente de la bibliothèque qui possède aussi un support pour toutes les langues principales. Avec cela, vous pouvez concevoir votre propre solution pour savoir comment vous souhaitez communiquer (et pas seulement purement RPC). Il comporte des motifs de demande/réponse, push/pull, pub/sub, et de la paire. Il vous donne assez d'outils pour mettre ensemble un système évolutif de tout type.

J'ai utilisé les deux et ils sont d'excellentes solutions.

Juste un exemple grossier, l'Épargne spécification peut être quelque chose comme ça. Imaginons que vous voulez communiquer sur les événements de python pour node.js ont-il traité et d'obtenir une réponse:

myspec.l'épargne
```
struct Event {
    1: string message; 
}

service RpcService {
    string eventOccurred(1:Event e)
}
```
Ceci définit une structure de données appelée Event avec une seule chaîne de membre par le message. Ensuite, un service appelé RpcService définir une fonction appelée eventOccured qui s'attend à une Event comme argument et retourne une chaîne de caractères.

Lorsque vous générer ce code en python et node.js vous pouvez ensuite utiliser le code côté client pour python et le code côté serveur pour node.js

python
```
from myrpc import RpcService, ttypes

# create a connection somewhere in your code
CONN = connect_to_node(port=9000)

def someoneClickedSomething():
    event = ttypes.Event("Someone Clicked!")
    resp = CONN.eventOccurred(event)
    print "Got reply:", resp
```
node.js
```
//I don't know node.js, so this is just pseudo-code

var thrift = require('thrift');
var myrpc = require('myrpc.js');

var server = thrift.createServer(myrpc.RpcService, {
  eventOccurred: function(event) {
    console.log("event occured:", event.message);
    success("Event Processed.");
  },
});
server.listen(9000);
```
2

Vous pouvez regarder certains systèmes de messagerie comme 0mq http://www.zeromq.org/
2

J'ai utilisé la bibliothèque inspiré par cette question à son tour diagnosis.py dans une Prise.IO client. De cette façon, je peux émettre des données en temps réel à l'Node.js Socket.IO server:
```
socketIO.emit('gaze', ...)
```
Et puis de faire un socket.broadcast.emit pour émettre les données de tous les Socket.IO clients (navigateur et diagnosis.py).

RPC est probablement le plus de l'approche standard pour la croix-développement du langage, mais je trouve que c'est un peu exagéré de le faire lorsque l'objectif est d'échanger des données. Il ne prend pas en charge evented IO hors de la boîte.

Mise à jour sur Jan 2013 Depuis socket.broadcast.emit génère beaucoup de trafic inutile, j'ai essayé de trouver une meilleure façon de le faire. La solution que j'ai trouvé est d'utiliser des espaces de noms qui est pris en charge par la base de python Socket.IO bibliothèque de client que j'ai mentionnés.

Python
```
self.mainSocket = SocketIO('localhost', 80)
self.gazeSocket = self.mainSocket.connect('/gaze')
self.gazeSocket.emit('gaze', ...)
```
Pour se connecter au regard de l'espace de noms.

Node.js
```
var gaze = io.of('/gaze').on('connection', function (socket) {
    socket.on('gaze', function (gdata) {
        gaze.emit('gaze', gdata.toString());
    });
});
```
Ce émet les données reçues uniquement pour les clients connectés au regard de l'espace de noms.

Navigateur
```
var socket = io.connect('http://localhost/gaze');
socket.on('gaze', function (data) {
    console.log(data);
});
```
1

Si vous êtes simplement à la recherche de quelque chose qui vous donne un protocole simple sur le dessus de sockets, donc vous n'avez pas à traiter avec mise en mémoire tampon et la délimitation des messages et tout ça, les deux choix évidents (selon le type de données que vous essayez d'envoyer) sont netstrings et JSON-RPC. Il y a plusieurs choix de bibliothèques pour les deux, dans les deux langues, mais vous pouvez vous retrouver avec un code aussi simple que cela:
```
class MyService(Service):
    # … code to set up the newsdb
    def getnews(self, category, item):
        return self.newsdb.get(category, item)
myService = MyService(6000)

myService = Service(6000)
//… code to set up the newsdb
myService.getnews = function(category, item, callback) {
    callback(this.newsdb.get(category, item);
}
```

Vous devez vous connecter pour publier un commentaire.