Découverte de service flexible, solide et portable

Question

Je suis à la recherche d'un moyen pour les clients dans un réseau local pour trouver toutes les instances de mon application serveur sans aucune configuration. Au lieu de piratage quelque chose moi-même, je voudrais utiliser une solution existante. Personnellement, j'ai besoin d'être fait en Python, mais je heureux d'entendre parler des solutions dans une autre langue.

Alors, pourquoi suis-je pas en utilisant Avahi ou OpenSLP ou autre Zeroconf / SLP solution? Eh bien, il y a deux ou trois critères supplémentaires, et je suis sous l'impression qu'aucun des systèmes mentionnés ci-dessus les matches.

Je suis à la recherche d'une solution qui est:

• Flexible . Il ne doit pas exiger des droits super-utilisateur, à savoir utiliser uniquement les ports> 1024.
• solide . Il doit permettre à plusieurs services du même et différents types de services sur une seule machine et continuer la publicité des services, même lorsque l'instance qui a commencé le serveur publicitaire arrête ou se bloque.
• Portable . Il doit fonctionner presque partout, ou du moins sur * BSD, Debian / gentoo / RedHat / SuSe Linux, Mac OS X, Solaris et Windows NT.
• Lumière . Idéalement, un script Python serait la seule solution. Je ne suis pas le moins intéressé par autoconfiguration d'adresse ou quelque chose comme ça, même si je contrecœur accepte une solution qui a beaucoup de fonctionnalités que je ne ai pas besoin. En outre, une configuration unique est une stricte non-non.

Je me attends quelque chose comme ceci:

def registerService(service): # (type, port)
    if listen(multicast, someport):
        if fork() == child:
            services = [service]
            for q in queriesToMe():
                if q == DISCOVERY:
                    answer(filter(q.criteria, services))
                elif q == ADVERTISE and q.sender == "localhost":
                    services.append(q.service)
    else:
        advertiseAt("localhost", service)

Answer 1

J'ai écrit une application / bibliothèque (actuellement Python et l'interface CLI) qui correspond à tous ces critera. Il est appelé minusconf . Il s'avère que fork est même pas nécessaire.

Answer 2

Pour la découverte de nœud dans un réseau local que j'ai utilisé Twisted et UDP multicast. Espérons que cela vous aide aussi.

Lien vers la documentation tordue qui explique comment le faire: https://twistedmatrix.com/documents/current/core/howto/udp .html # AUTO3

Voici une implémentation de base d'un serveur / client basé dans le code du tordu. Il se répond si vous exécutez une fois, mais tout le code de vérification et des fonctionnalités supplémentaires ont été supprimés afin de le rendre plus simple à lire.

from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor

class MulticastPingPong(DatagramProtocol):
    MULTICAST_ADDR = ('228.0.0.5', 8005)
    CMD_PING = "PING"
    CMD_PONG = "PONG"

    def startProtocol(self):
        """
        Called after protocol has started listening.
        """
        # Set the TTL>1 so multicast will cross router hops:
        self.transport.setTTL(5)
        # Join a specific multicast group:
        self.transport.joinGroup(self.MULTICAST_ADDR[0])

        self.send_alive()

    def send_alive(self):
        """
        Sends a multicast signal asking for clients.
        The receivers will reply if they want to be found.
        """
        self.transport.write(self.CMD_PING, self.MULTICAST_ADDR)

    def datagramReceived(self, datagram, address):
        print "Datagram %s received from %s" % (repr(datagram), repr(address))

        if datagram.startswith(self.CMD_PING):
            # someone publishes itself, we reply that we are here
            self.transport.write(self.CMD_PONG, address)
        elif datagram.startswith(self.CMD_PONG):
            # someone reply to our publish message
            print "Got client: ", address[0], address[1]


if __name__ == '__main__':
    reactor.listenMulticast(8005, MulticastPingPong(), listenMultiple=True)
    reactor.run()

Answer 3

Je suppose que vous avez le contrôle sur les applications client, pas seulement l'application serveur, auquel cas Pyro pourrait bien fonctionner pour vous.

Flexible:. utilise les ports non privilégiés

Solide: Il a été bien entretenu depuis de nombreuses années

.

Portable:. Pur Python et bien testé sur plusieurs plates-formes

Lumière: Je pense que Pyro est la lumière de ce que vous obtenez. Peut-être demander pour l'un script Python est irréaliste pour un service de nommage de réseau?

Même si vous ne voulez pas utiliser réellement le paradigme « objet distant » de Pyro, vous pourriez encore être en mesure de simplement utiliser son service de nommage.