Come percorso tutti i sottodomini a un singolo host tramite mDNS?

Question

Ho un web server di sviluppo di hosting come "myhost.local" che si trova utilizzando Bonjour / mDNS. Il server esegue avahi-daemon.

Il server web vuole anche per gestire eventuali sottodomini di se stesso. Ad esempio "cat.myhost.local" e "dog.myhost.local" e "guppy.myhost.local".

Dato che myhost.local si trova su un indirizzo IP dinamico da DHCP, c'è ancora un modo per indirizzare tutte le richieste dei sottodomini per myhost.local?

sto iniziando a pensare che non attualmente possibile ...

http://marc.info/?l=freedesktop-avahi&m=119561596630960&w= 2

  

    

È possibile farlo con il file / etc / avahi / hosts. In alternativa è possibile
    utilizzare-pubblicare-host-name avahi.

  

     

No, non può. Dal momento che lui vuole definire un alias, non una nuova   Nome host. Cioè vuole solo registrare un A RR, nessun contrario PTR RR. Ma   se ti infili qualcosa in / etc / Avahi / hosts allora registra sia,   e rileva una collisione se la RR PTR è non univoco, che sarebbe il   caso per un alias.

Answer 1

ho dato in su come non è possibile, al momento, e non ho rivisitato il problema allora.

La mia soluzione attuale è quella di aggiungere faticosamente ogni sottodominio di interesse per il file hosts sul computer locale.

Answer 2

Ho risolto questo come meglio che posso con la piccola quantità di tempo ho assegnato a questo compito.

Ma purtroppo non credo che l'implementazione di Windows di avahi / msdns / bonjour supporta gli alias (correggetemi se sbaglio con esempi di come a sostegno di questa).

Quello che ho fatto è stato iniziare con lo script di esempio python fornite sul sito web Avahi:

Crea: /usr/bin/avahi-announce-alias

Lo rendono eseguibile e Riempire con

#! /usr/bin/env python
# avahi-alias.py

import avahi, dbus
from encodings.idna import ToASCII

# Got these from /usr/include/avahi-common/defs.h
CLASS_IN = 0x01
TYPE_CNAME = 0x05

TTL = 60

def publish_cname(cname):
    bus = dbus.SystemBus()
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER),
            avahi.DBUS_INTERFACE_SERVER)
    group = dbus.Interface(bus.get_object(avahi.DBUS_NAME, server.EntryGroupNew()),
            avahi.DBUS_INTERFACE_ENTRY_GROUP)

    rdata = createRR(server.GetHostNameFqdn())
    cname = encode_dns(cname)

    group.AddRecord(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32(0),
        cname, CLASS_IN, TYPE_CNAME, TTL, rdata)
    group.Commit()


def encode_dns(name):
    out = []
    for part in name.split('.'):
        if len(part) == 0: continue
        out.append(ToASCII(part))
    return '.'.join(out)

def createRR(name):
    out = []
    for part in name.split('.'):
        if len(part) == 0: continue
        out.append(chr(len(part)))
        out.append(ToASCII(part))
    out.append('\0')
    return ''.join(out)

if __name__ == '__main__':
    import time, sys, locale
    for each in sys.argv[1:]:
        name = unicode(each, locale.getpreferredencoding())
        publish_cname(name)
    try:
        # Just loop forever
        while 1: time.sleep(60)
    except KeyboardInterrupt:
        print "Exiting"

Questo script gestisce l'annuncio di ogni singolo alias, e rimarrà in esecuzione fino a quando si uccide. (A causa di questo, abbiamo bisogno di creare un altro script che ho mostrato qui sotto)

Crea file di testo /etc/avahi/aliases

Questo ci utilizzare per memorizzare gli alias a questa macchina uno per riga

Crea directory /etc/avahi/aliases.d/

Non ho effettivamente fatto uso di questo in uno qualsiasi dei copioni che mostro qui ancora, ma per quegli individui intraprendenti là fuori, si può vedere che cosa deve essere fatto.

L'idea è che si può alias di gruppo in file di testo separati (che renderà più senso quando avete a che fare con gli host virtuali in apache), questo è qualcosa che molte applicazioni daemon su * nix già forniscono (apache e apt sono solo due esempi ).

Crea /usr/bin/avahi-announce-aliases

Lo rendono eseguibile e riempirlo con

#!/usr/bin/env python

import os, sys
from subprocess import Popen


def ensure_file (path):
    """
        Looks for  file at provided path, creates it if it does not exist.
        Returns the file.
    """
    rfile = None    
    if not os.path.exists(path) and os.path.isfile(path) :
        rfile = open(path,"w+");
        print("ensuring file : %s " % path)

    print("file ensured : %s " % path)
    return rfile


command = '/usr/bin/avahi-announce-alias'
alias_pid_path = "/tmp/avahi-aliases.pid"
alias_file_path = "/etc/avahi/aliases"

alias_file = open(alias_file_path)
if not os.path.exists(alias_pid_path) :
    open(alias_pid_path,"w").close()

alias_pid = open(alias_pid_path,"r")


for line in alias_pid :
    txt = line.strip('\n')
    if len(txt) > 0 :
        print("kill %s" % txt )
        os.system("kill %s" % txt)          
alias_pid.close()
alias_pid = open(alias_pid_path,"w+")

for line in alias_file :
    txt = line.strip('\n')
    if len(txt) > 0 :
        print("publishing : << %s >>" % txt)
        process = Popen([command, txt])
        alias_pid.write("%s\n" % str(process.pid))    
alias_pid.close()

print("done")

E 'in alcun modo vuole essere l'apice della programmazione python, quindi sentitevi liberi di apportare miglioramenti in cui si vede in forma.

Uso

Se il nostro nome host è "server" e il avahi-hostname era "server.local", allora potremmo riempire il file di testo /etc/avahi/aliases con i vostri nomi di host in più in questo modo:

deluge.server.local
username.server.local
accounts.server.local
something-else.server.local
another.hostname.home

(ma in realtà, sono abbastanza sicuro che si potrebbe avere alcun nome host in là fornendo fatto in modo che non esiste già sulla rete, ed è per questo ho appena creo 'sottodomini' della normale hostname Avahi)

Poi corriamo:

sudo avahi-publish-aliases

La ragione principale per impostare questa funzione era quello di facilitare più facile simulazione di Django e Drupal sviluppo sul mio portatile.

Avvertimenti

La mia unica delusione è che l'implementazione di Windows di Bonjour / Avahi non supporta gli alias che questa implementazione annuncia, si vedrà solo l'Avahi principale hostname normalmente annunciato (cioè server.local nel nostro esempio di cui sopra).

Answer 3

appare come airtonix implementato questo e reso disponibile alla pagina https://github.com/airtonix/avahi- alias

Una più recente forchetta aggiornato che ho testato su Ubuntu 11.04 è a https://github.com / hmalphettes / avahi-alias

Answer 4

È possibile registrare ulteriori record utilizzando l'API Avahi. Questo esempio sulla wiki Avahi dimostra come pubblicare ulteriori record CNAME (alias) in Python .

Answer 5

So che questo è vecchio, ma una soluzione migliore sarebbe dnsmasq .

Questo può essere realizzato in modo così semplice ... tramite gli argomenti / config ...

  

Rientro ipaddr per tutti gli host in domini specificati.

     

-A, --address=/<domain>/<ipaddr>