Flessibile, solido e portatile Discovery Service

Question

Sto cercando un modo per i clienti in una rete LAN per trovare tutte le istanze della mia applicazione server senza alcuna configurazione. Invece di incisione qualcosa di me stesso, mi piacerebbe utilizzare una soluzione esistente. Personalmente, ho bisogno di essere fatto in Python, ma mi piacerebbe felice di sentir parlare di soluzioni in qualsiasi altra lingua.

Quindi, perché non sto usando avahi o OpenSLP o qualche altro Zeroconf / SLP soluzione? Beh, ci sono un paio di criteri aggiuntivi, e sono sotto l'impressione nessuno dei sistemi di cui sopra li corrisponde.

Sto cercando una soluzione che sia:

• flessibile . Non deve richiedere diritti di superutente, cioè utilizzare solo le porte> 1024.
• Solid . Deve consentire a più servizi dello stesso e diverso tipo di servizio su una singola macchina e continuare a fare pubblicità ai servizi, anche quando l'istanza che ha avviato il server di pubblicità si ferma o si blocca.
• Portable . Si deve correre quasi ovunque, o almeno su * BSD, Debian / gentoo / RedHat / SuSe Linux, Mac OS X, Solaris e Windows NT.
• Light . Idealmente, uno script Python sarebbe l'intera soluzione. Io non sono minimamente interessati a indirizzo autoconfigurazione o qualcosa di simile, anche se mi piacerebbe malincuore accettare una soluzione che ha un sacco di funzioni non ho bisogno. Inoltre, qualsiasi messa a punto di una volta è un rigoroso no-no.

Mi aspetto qualcosa di simile:

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

Ho scritto un programma / libreria (attualmente Python e l'interfaccia CLI) che soddisfa tutti questi critera. Si chiama minusconf . Risulta biforcazione non è nemmeno necessario.

Answer 2

Per la scoperta nodo in una rete LAN ho usato ritorto e UDP multicast. Spero che ti aiuta anche.

link alla documentazione contorta che spiega come farlo: https://twistedmatrix.com/documents/current/core/howto/udp .html # Auto3

Ecco un'implementazione di base di un server / client basato nel codice del contorto. Si risponde se si esegue una volta, ma tutto il codice di controllo e funzioni extra sono stati rimossi in modo da rendere più semplice la lettura.

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

I suppone che si abbia il controllo sulle applicazioni client, non solo l'applicazione server, nel qual caso Pyro potrebbe funzionare bene per voi.

flessibile:. utilizza le porte non privilegiate

Solid: è stato ben mantenuto per molti anni

.

Portatile:. Python puro e ben testato su più piattaforme

Light: Credo Pyro è luce per quello che stai ricevendo. Forse chiedere uno script Python è realistico per un servizio di rete di denominazione?

Anche se non si desidera utilizzare effettivamente il paradigma "oggetto remoto" di Pyro, è ancora potrebbe essere in grado di utilizzare solo il suo servizio di denominazione.