Como rota todos os subdomínios para um único host usando mDNS?

Question

Eu tenho um desenvolvimento servidor web hosting como "myhost.local" que é encontrado usando Bonjour / mDNS. O servidor está executando avahi-daemon.

O servidor web também quer lidar com todos os subdomínios de si mesmo. Por exemplo, "cat.myhost.local" e "dog.myhost.local" e "guppy.myhost.local".

Dado que myhost.local está em um endereço IP dinâmico a partir de DHCP, é ainda uma forma de encaminhar todas as solicitações para os subdomínios para myhost.local?

Estou começando a pensar que não possível atualmente ...

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

Você pode fazer isso com o etc / avahi / arquivo / hosts. Alternativamente, você pode
usar avahi-publicar-host-name.

Não, ele não pode. Desde que ele quer definir um alias, não uma nova nome de anfitrião. Ou seja, ele só quer registar um RR, nenhuma RR PTR inversa. Mas se você ficar algo em / etc / avahi / hosts, em seguida, ele registra ambos, e detecta uma colisão se o PTR RR é não-exclusiva, que seria o caso para um alias.

Answer 1

Eu dei-lo como não é possível no momento, e eu não ter revisitado o problema desde então.

Minha solução atual é adicionar laboriosamente cada subdomínio de interesse para o arquivo hosts na máquina local.

Answer 2

Eu já resolveu este o melhor que pode com a pequena quantidade de tempo que eu atribuído a esta tarefa.

Mas, infelizmente, eu não acho que a implementação janelas de avahi / msdns / bonjour suporta aliases (me corrija se eu estiver errado com exemplos de como apoiar este).

O que fiz foi começar com o script exemplo python fornecido no site avahi:

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

torná-lo executável & Encha-o com

#! /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"

Este script controla o anúncio de cada alias individuais, e permanecerá em execução até que você matá-lo. (Por isso, precisamos criar outro script que eu tenho mostrado abaixo)

Criar arquivo de texto /etc/avahi/aliases

Esta usamos para armazenar aliases para esta máquina um por linha

Criar diretório /etc/avahi/aliases.d/

Eu não tenho realmente fez uso desta em qualquer dos scripts eu mostro aqui ainda, mas para aqueles indivíduos empreendedores lá fora, você pode ver o que precisa ser feito.

A idéia é que você pode aliases de grupo para arquivos de texto separados (que fará mais sentido quando você lida com hosts virtuais em apache), isso é algo que muitas aplicações daemon em * nix já fornecem (apache e apt são apenas dois exemplos ).

Criar /usr/bin/avahi-announce-aliases

Faça-o executável e preenchê-lo com

#!/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")

Ele não é de forma significava para ser o auge de programação Python, então sinta-se livre para fazer melhorias onde você vê o ajuste.

Uso

Se a nossa hostname era "servidor" e o avahi-hostname era "server.local", então poderíamos encher o arquivo de texto /etc/avahi/aliases com os seus nomes de host extras assim:

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

(mas realmente, eu tenho certeza que você pudesse ter qualquer hostname lá fornecendo-lhe a certeza que já não existe na rede, o que é por isso que eu só criar 'subdomínios' do normal, avahi hostname)

Em seguida, execute:

sudo avahi-publish-aliases

O principal motivo para essa configuração era facilitar mais fácil simulação de Django e desenvolvimento de sites Drupal no meu laptop.

Advertências

A minha única decepção é que a implementação janelas de Bonjour / Avahi não suporta os aliases que esta implementação anuncia, ela só vai ver a principal avahi hostname normalmente anunciou (ie server.local em nosso exemplo acima).

Answer 3

Looks como airtonix implementado este e disponibilizado em https://github.com/airtonix/avahi- aliases

A mais recente garfo atualizado que eu testei no Ubuntu 11.04 é em https://github.com / hmalphettes / avahi-aliases

Answer 4

Você pode registrar registros adicionais usando a API Avahi. Este exemplo no wiki Avahi demonstra como publicar registros adicionais CNAME (alias) em Python .

Answer 5

Eu sei que este é antiga, mas uma solução melhor seria dnsmasq .

Isso pode ser feito de maneira tão simples ... via os argumentos / config ...

Voltar ipaddr para todos os hosts em domínios especificados.

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

??

address=/yourdomain.com/10.0.1.100

Voila!