def __str__(me):
return "failed to resolve `%s': %s" % (me.host, me.msg)
+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 = []
+ me.failure = None
+
+ def addaddr(me, addr):
+ """Add the address ADDR."""
+ me.addr.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 = me.addr
+ all = False
+ for ch in flags:
+ if ch == '*': all = True
+ else: raise ValueError("unknown address-resolution flag `%s'" % ch)
+ if not aa: raise ResolverFailure(me.name, 'no matching addresses found')
+ if not all: aa = [aa[0]]
+ return aa
+
class BulkResolver (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))
+ me._noutstand = 0
+
+ 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)
+ host._resolv = M.SelResolveByName(
+ name,
+ lambda cname, alias, addr: me._resolved(host, addr),
+ lambda: me._resolved(host, []))
+ 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 lookup(me, host):
- """
- Fetch the address corresponding to HOST.
- """
- addr = me._namemap[host]
- if addr is None:
- raise ResolverFailure(host, '(unknown failure)')
- return addr
+ def lookup(me, name, flags):
+ """Fetch the address corresponding to the host NAME."""
+ return me._namemap[name].get(flags)
def _resolved(me, host, addr):
- """Callback function: remember that ADDR is the address for HOST."""
- me._namemap[host] = addr
- del me._resolvers[host]
+ """Callback function: remember that ADDRs are the addresses for HOST."""
+ if not addr:
+ host.failed('(unknown failure)')
+ else:
+ for a in addr: host.addaddr(a)
+ host._resolv = None
+ me._noutstand -= 1
###--------------------------------------------------------------------------
### 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) \$ ([*]*) \[ ([^]]+) \]')
class ConfigSyntaxError (ExpectedError):
def __init__(me, fname, lno, msg):
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):
* 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 may be empty, or `*' (all addresses, 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()
###--------------------------------------------------------------------------
~mdw / tripe / blobdiff