def finish(me):
pass
+class ExpectedError (Exception): pass
+
###--------------------------------------------------------------------------
### A bulk DNS resolver.
+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 ResolvingHost (object):
+ """
+ A host name which is being looked up by a bulk-resolver instance.
+ """
+
+ def __init__(me, name):
+ """Make a new resolving-host object for the host NAME."""
+ me.name = name
+ me.addr = None
+ me.failure = None
+
+ def setaddr(me, addr):
+ """Add the address ADDR."""
+ me.addr = addr
+
+ def failed(me, msg):
+ """
+ Report that resolution of this host failed, with a human-readable MSG.
+ """
+ me.failure = msg
+
+ def get(me):
+ """Return the resolved address."""
+ if me.failure is not None: raise ResolverFailure(me.name, me.failure)
+ return me.addr
+
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[0]),
+ 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 lookup(me, host):
- """
- Fetch the address corresponding to HOST.
- """
- addr = me._namemap[host]
- if addr is None:
- raise KeyError(host)
- return addr
+ def lookup(me, name):
+ """Fetch the address corresponding to the host NAME."""
+ return me._namemap[name].get()
def _resolved(me, host, addr):
"""Callback function: remember that ADDR is the address for HOST."""
- me._namemap[host] = addr
- del me._resolvers[host]
+ if addr is None:
+ host.failed('(unknown failure)')
+ else:
+ host.setaddr(addr)
+ host._resolv = None
+ me._noutstand -= 1
###--------------------------------------------------------------------------
### The configuration parser.
## Match a $[HOST] name resolution reference; group 1 is the HOST.
RX_RESOLVE = RX.compile(r'(?x) \$ \[ ([^]]+) \]')
-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
## Special handling for the `name' key.
if key == 'name':
value = me._itemmap.get('name', me.name)
+ elif key == '@inherits':
+ try: return me._itemmap['@inherits']
+ except KeyError: raise MissingKeyException(me.name, key)
else:
value, _ = me._get(key)
if value is None:
"""
## Initialize for a depth-first walk of the inheritance graph.
- d = {}
- visited = {}
+ seen = { 'name': True }
+ visiting = { me.name: True }
stack = [me]
## Visit nodes, collecting their keys. Don't believe the values:
## resolving inheritance is too hard to do like this.
while stack:
sec = stack.pop()
- if sec.name in visited: continue
- visited[sec.name] = True
- stack += sec._parents()
+ for p in sec._parents():
+ if p.name not in visiting:
+ stack.append(p); visiting[p.name] = True
- for key in sec._itemmap.iterkeys():
- if key != '@inherit': d[key] = None
+ for key in sec._itemmap.iterkeys(): seen[key] = None
## And we're done.
- return d.iterkeys()
+ return seen.iterkeys()
class MyConfigParser (object):
"""
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()