from optparse import OptionParser
import cdb as CDB
from sys import stdin, stdout, exit, argv
+import subprocess as SUB
import re as RX
import os as OS
+import errno as E
+import fcntl as F
+import socket as S
from cStringIO import StringIO
###--------------------------------------------------------------------------
def finish(me):
pass
+class ExpectedError (Exception): pass
+
###--------------------------------------------------------------------------
### A bulk DNS resolver.
-class ResolverFailure (Exception):
+class ResolverFailure (ExpectedError):
def __init__(me, host, msg):
me.host = host
me.msg = msg
def __str__(me):
return "failed to resolve `%s': %s" % (me.host, me.msg)
-class BulkResolver (object):
+class ResolvingHost (object):
+ """
+ A host name which is being looked up by a bulk-resolver instance.
+
+ Most notably, this is where the flag-handling logic lives for the
+ $FLAGS[HOSTNAME] syntax.
+ """
+
+ def __init__(me, name):
+ """Make a new resolving-host object for the host NAME."""
+ me.name = name
+ me.addr = { 'INET': [], 'INET6': [] }
+ me.failure = None
+
+ def addaddr(me, af, addr):
+ """
+ Add the address ADDR with address family AF.
+
+ The address family may be `INET' or `INET6'.
+ """
+ me.addr[af].append(addr)
+
+ def failed(me, msg):
+ """
+ Report that resolution of this host failed, with a human-readable MSG.
+ """
+ me.failure = msg
+
+ def get(me, flags):
+ """Return a list of addresses according to the FLAGS string."""
+ if me.failure is not None: raise ResolverFailure(me.name, me.failure)
+ aa = []
+ a4 = me.addr['INET']
+ a6 = me.addr['INET6']
+ all, any = False, False
+ for ch in flags:
+ if ch == '*': all = True
+ elif ch == '4': aa += a4; any = True
+ elif ch == '6': aa += a6; any = True
+ else: raise ValueError("unknown address-resolution flag `%s'" % ch)
+ if not any: aa = a4 + a6
+ if not aa: raise ResolverFailure(me.name, 'no matching addresses found')
+ if not all: aa = [aa[0]]
+ return aa
+
+class BaseBulkResolver (object):
"""
Resolve a number of DNS names in parallel.
def __init__(me):
"""Initialize the resolver."""
- me._resolvers = {}
me._namemap = {}
- def prepare(me, host):
- """Prime the resolver to resolve the name HOST."""
- if host not in me._resolvers:
- me._resolvers[host] = M.SelResolveByName \
- (host,
- lambda name, alias, addr:
- me._resolved(host, addr[0]),
- lambda: me._resolved(host, None))
+ def prepare(me, name):
+ """Prime the resolver to resolve the given host NAME."""
+ if name not in me._namemap:
+ me._namemap[name] = host = ResolvingHost(name)
+ try:
+ ailist = S.getaddrinfo(name, None, S.AF_UNSPEC, S.SOCK_DGRAM, 0,
+ S.AI_NUMERICHOST | S.AI_NUMERICSERV)
+ except S.gaierror:
+ me._prepare(host, name)
+ else:
+ for af, skty, proto, cname, sa in ailist:
+ if af == S.AF_INET: host.addaddr('INET', sa[0])
+ elif af == S.AF_INET6: host.addaddr('INET6', sa[0])
+
+ def lookup(me, name, flags):
+ """Fetch the address corresponding to the host NAME."""
+ return me._namemap[name].get(flags)
+
+class BresBulkResolver (BaseBulkResolver):
+ """
+ A BulkResolver using mLib's `bres' background resolver.
+
+ This is always available (and might use ADNS), but only does IPv4.
+ """
+
+ def __init__(me):
+ super(BresBulkResolver, me).__init__()
+ """Initialize the resolver."""
+ me._noutstand = 0
+
+ def _prepare(me, host, name):
+ """Arrange to resolve a NAME, reporting the results to HOST."""
+ host._resolv = M.SelResolveByName(
+ name,
+ lambda cname, alias, addr: me._resolved(host, cname, addr),
+ lambda: me._resolved(host, None, []))
+ me._noutstand += 1
def run(me):
"""Run the background DNS resolver until it's finished."""
- while me._resolvers:
- M.select()
+ while me._noutstand: M.select()
+
+ def _resolved(me, host, cname, addr):
+ """Callback function: remember that ADDRs are the addresses for HOST."""
+ if not addr:
+ host.failed('(unknown failure)')
+ else:
+ if cname is not None: host.name = cname
+ for a in addr: host.addaddr('INET', a)
+ host._resolv = None
+ me._noutstand -= 1
+
+class AdnsBulkResolver (BaseBulkResolver):
+ """
+ A BulkResolver using ADNS, via the `adnshost' command-line tool.
+
+ This can do simultaneous IPv4 and IPv6 lookups and is quite shiny.
+ """
- def lookup(me, host):
+ def __init__(me):
+ """Initialize the resolver."""
+
+ super(AdnsBulkResolver, me).__init__()
+
+ ## Start the external resolver process.
+ me._kid = SUB.Popen(['adnshost', '-afs'],
+ stdin = SUB.PIPE, stdout = SUB.PIPE)
+
+ ## Set up the machinery for feeding input to the resolver.
+ me._in = me._kid.stdin
+ M.fdflags(me._in, fbic = OS.O_NONBLOCK, fxor = OS.O_NONBLOCK)
+ me._insel = M.SelFile(me._in.fileno(), M.SEL_WRITE, me._write)
+ me._inbuf, me._inoff, me._inlen = '', 0, 0
+ me._idmap = {}
+ me._nextid = 0
+
+ ## Set up the machinery for collecting the resolver's output.
+ me._out = me._kid.stdout
+ M.fdflags(me._out, fbic = OS.O_NONBLOCK, fxor = OS.O_NONBLOCK)
+ me._outline = M.SelLineBuffer(me._out,
+ lineproc = me._hostline, eofproc = me._eof)
+ me._outline.enable()
+
+ ## It's not finished yet.
+ me._done = False
+
+ def _prepare(me, host, name):
+ """Arrange for the resolver to resolve the name NAME."""
+
+ ## Work out the next job id, and associate that with the host record.
+ host.id = me._nextid; me._nextid += 1
+ me._namemap[name] = me._idmap[host.id] = host
+
+ ## Feed the name to the resolver process.
+ me._inbuf += name + '\n'
+ me._inlen += len(name) + 1
+ if not me._insel.activep: me._insel.enable()
+ while me._inoff < me._inlen: M.select()
+
+ def _write(me):
+ """Write material from `_inbuf' to the resolver when it's ready."""
+
+ ## Try to feed some more material to the resolver.
+ try: n = OS.write(me._in.fileno(), me._inbuf[me._inoff:])
+ except OSError, e:
+ if e.errno == E.EAGAIN or e.errno == E.EWOULDBLOCK: return
+ else: raise
+
+ ## If we're done, then clear the buffer.
+ me._inoff += n
+ if me._inoff >= me._inlen:
+ me._insel.disable()
+ me._inbuf, me._inoff, me._inlen = '', 0, 0
+
+ def _eof(me):
+ """Notice that the resolver has finished."""
+ me._outline.disable()
+ me._done = True
+ me._kid.wait()
+
+ def run(me):
"""
- Fetch the address corresponding to HOST.
+ Tell the resolver it has all of our input now, and wait for it to finish.
"""
- addr = me._namemap[host]
- if addr is None:
- raise ResolverFailure(host, '(unknown failure)')
- return addr
-
- def _resolved(me, host, addr):
- """Callback function: remember that ADDR is the address for HOST."""
- me._namemap[host] = addr
- del me._resolvers[host]
+ me._in.close()
+ while not me._done: M.select()
+ if me._idmap:
+ raise Exception('adnshost failed to process all the requests')
+
+ def _hostline(me, line):
+ """Handle a host line from the resolver."""
+
+ ## Parse the line into fields.
+ (id, nrrs, stty, stocde, stmsg, owner, cname, ststr), _ = \
+ M.split(line, quotep = True)
+ id, nrrs = int(id), int(nrrs)
+
+ ## Find the right record.
+ host = me._idmap[id]
+ if stty != 'ok': host.failed(ststr)
+
+ ## Stash away the canonical name of the host.
+ host.name = cname == '$' and owner or cname
+
+ ## If there are no record lines to come, then remove this record from the
+ ## list of outstanding jobs. Otherwise, switch to the handler for record
+ ## lines.
+ if not nrrs:
+ del me._idmap[id]
+ else:
+ me._outline.lineproc = me._rrline
+ me._nrrs = nrrs
+ me._outhost = host
+
+ def _rrline(me, line):
+ """Handle a record line from the resolver."""
+
+ ## Parse the line into fields.
+ ww, _ = M.split(line, quotep = True)
+ owner, type, af = ww[:3]
+
+ ## If this is an address record, and it looks like an interesting address
+ ## type, then stash the address.
+ if type == 'A' and (af == 'INET' or af == 'INET6'):
+ me._outhost.addaddr(af, ww[3])
+
+ ## Update the parser state. If there are no more records for this job
+ ## then mark the job as done and switch back to expecting a host line.
+ me._nrrs -= 1
+ if not me._nrrs:
+ me._outline.lineproc = me._hostline
+ del me._idmap[me._outhost.id]
+ me._outhost = None
+
+## Select a bulk resolver. If `adnshost' exists then we might as well use
+## it.
+BulkResolver = BresBulkResolver
+try:
+ p = SUB.Popen(['adnshost', '--version'],
+ stdin = SUB.PIPE, stdout = SUB.PIPE, stderr = SUB.PIPE)
+ _out, _err = p.communicate()
+ st = p.wait()
+ if st == 0: BulkResolver = AdnsBulkResolver
+except OSError:
+ pass
###--------------------------------------------------------------------------
### The configuration parser.
## Match a $(VAR) configuration variable reference; group 1 is the VAR.
RX_REF = RX.compile(r'(?x) \$ \( ([^)]+) \)')
-## Match a $[HOST] name resolution reference; group 1 is the HOST.
-RX_RESOLVE = RX.compile(r'(?x) \$ \[ ([^]]+) \]')
+## Match a $FLAGS[HOST] name resolution reference; group 1 are the flags;
+## group 2 is the HOST.
+RX_RESOLVE = RX.compile(r'(?x) \$ ([46*]*) \[ ([^]]+) \]')
-class ConfigSyntaxError (Exception):
+class ConfigSyntaxError (ExpectedError):
def __init__(me, fname, lno, msg):
me.fname = fname
me.lno = lno
def _fmt_path(path):
return ' -> '.join(["`%s'" % hop for hop in path])
-class AmbiguousOptionError (Exception):
+class AmbiguousOptionError (ExpectedError):
def __init__(me, key, patha, vala, pathb, valb):
me.key = key
me.patha, me.vala = patha, vala
"path %s yields `%s' but %s yields `%s'" % \
(me.key, _fmt_path(me.patha), me.vala, _fmt_path(me.pathb), me.valb)
-class InheritanceCycleError (Exception):
+class InheritanceCycleError (ExpectedError):
def __init__(me, key, path):
me.key = key
me.path = path
return "Found a cycle %s looking up key `%s'" % \
(_fmt_path(me.path), me.key)
-class MissingSectionException (Exception):
+class MissingSectionException (ExpectedError):
def __init__(me, sec):
- me.key = key
+ me.sec = sec
def __str__(me):
return "Section `%s' not found" % (me.sec)
-class MissingKeyException (Exception):
+class MissingKeyException (ExpectedError):
def __init__(me, sec, key):
me.sec = sec
me.key = key
def _expand(me, string, resolvep):
"""
- Expands $(...) and (optionally) $[...] placeholders in STRING.
+ Expands $(...) and (optionally) $FLAGS[...] placeholders in STRING.
RESOLVEP is a boolean switch: do we bother to tax the resolver or not?
This is turned off by MyConfigParser's resolve() method while it's
collecting hostnames to be resolved.
"""
- string = RX_REF.sub \
- (lambda m: me.get(m.group(1), resolvep), string)
+ string = RX_REF.sub(lambda m: me.get(m.group(1), resolvep), string)
if resolvep:
- string = RX_RESOLVE.sub(lambda m: me._cp._resolver.lookup(m.group(1)),
- string)
+ string = RX_RESOLVE.sub(
+ lambda m: ' '.join(me._cp._resolver.lookup(m.group(2), m.group(1))),
+ string)
return string
def _parents(me):
path.append(me.name)
try:
- ## If we've been this way before on another pass through then return the
- ## value we found then. If we're still thinking about it then we've
- ## found a cycle.
+ ## If we've been this way before on another pass through then return
+ ## the value we found then. If we're still thinking about it then
+ ## we've found a cycle.
try: v, p = me._cache[key]
except KeyError: pass
else:
* It recognizes `$(VAR)' references to configuration variables during
expansion and processes them correctly.
- * It recognizes `$[HOST]' name-resolver requests and handles them
- correctly.
+ * It recognizes `$FLAGS[HOST]' name-resolver requests and handles them
+ correctly. FLAGS consists of characters `4' (IPv4 addresses), `6'
+ (IPv6 addresses), and `*' (all, space-separated, rather than just the
+ first).
* Its parsing behaviour is well-defined.
for key in sec.items():
value = sec.get(key, resolvep = False)
for match in RX_RESOLVE.finditer(value):
- me._resolver.prepare(match.group(1))
+ me._resolver.prepare(match.group(2))
me._resolver.run()
###--------------------------------------------------------------------------
if a in ('y', 'yes', 't', 'true', '1', 'on'): auto.append(sec.name)
try: u = sec.get('user')
except MissingKeyException: pass
- else: cdb.add('U%s' % u)
+ else: cdb.add('U%s' % u, sec.name)
url = M.URLEncode(semip = True)
for key in sorted(sec.items()):
if not key.startswith('@'):
cdb = CDB.cdbmake(opts.cdbfile, opts.cdbfile + '.new')
else:
cdb = CDBFake()
- conf = getconf(args[1:])
- output(conf, cdb)
+ try:
+ conf = getconf(args[1:])
+ output(conf, cdb)
+ except ExpectedError, e:
+ M.moan(str(e))
+ exit(2)
if __name__ == '__main__':
main()
~mdw / tripe / blobdiff