pvl-verkko: comparison bin/pvl.dns-hosts

equal deleted inserted replaced

-:36c980a6d04a
+:5ee3bcd5b4b5
 import pvl.args, optparse
 import pvl.dns.zone
 import pvl.dhcp.config
 import pvl.ldap.args
+import ipaddr
+import optparse
 import collections
 import re
 import logging; log = logging.getLogger('main')
 __version__ = '0.1'
 # output
 parser.add_option('--output-hosts',         metavar='FILE',
 help="Output hosts file")
+parser.add_option('--output-ip',            metavar='PREFIX',
+help="Output hosts by ip prefix")
 # defaults
 parser.set_defaults(
 )
 # apply
 pvl.args.apply(options, argv[0])
 return options, args
-def process_zone_hosts (options, file) :
+def import_zone_hosts (options, file) :
 """
 Yield host info from zonefile records.
 """
 for rr in pvl.dns.zone.ZoneRecord.load(file) :
 yield host, 'alias', rr.name
 else :
 log.warn("%s: unknown rr: %s", rr.name, rr)
-def process_dhcp_host (options, host, items) :
+def import_dhcp_host (options, host, items) :
 """
 Yield host infos from a dhcp host ... { ... }
 """
 hostname = None
 hostname = host
 if hostname :
 yield hostname, 'ethernet', ethernet
-def process_dhcp_hosts (options, blocks) :
+def import_dhcp_hosts (options, blocks) :
 """
 Process hosts from a parsed block
 """
 for block, items, blocks in blocks :
 log.info("%s", block)
 block, args = block[0], block[1:]
 if block == 'group' :
-for info in process_dhcp_hosts(options, blocks) :
+for info in import_dhcp_hosts(options, blocks) :
 yield info
 elif block == 'host' :
 host, = args
 try :
-for info in process_dhcp_host(options, host, items) :
+for info in import_dhcp_host(options, host, items) :
 yield info
 except ValueError as error :
 log.warn("%s: invalid host: %s", host, error)
 else:
 log.warn("ignore unknown block: %s", block)
-def process_dhcp_conf (options, file) :
+def import_dhcp_conf (options, file) :
 items, blocks = pvl.dhcp.config.DHCPConfigParser().load(file)
 for item in items :
 item, args = item[0], item[1:]
 if item == 'include' :
 include, = args
-for info in process_dhcp_conf(options, pvl.args.apply_file(include)) :
+for info in import_dhcp_conf(options, pvl.args.apply_file(include)) :
 yield info
 else :
 log.warn("ignore unknown item: %s", item)
-for info in process_dhcp_hosts(options, blocks) :
+for info in import_dhcp_hosts(options, blocks) :
 yield info
-def apply_hosts_import (options) :
-"""
-Import host infos from given files.
-"""
-if options.import_zone_hosts:
-for info in process_zone_hosts(options,
-pvl.args.apply_file(options.import_zone_hosts)) :
-yield info
-if options.import_dhcp_hosts:
-for info in process_dhcp_conf(options,
-pvl.args.apply_file(options.import_dhcp_hosts)) :
-yield info
 ZONE_COMMENTS = (
 re.compile(r'(?P<owner>[^/]+)\s*-\s+(?P<host>.+)'),
 re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[/-]\s+(?P<host>.+)'),
 re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[(]\s*(?P<host>.+)[)]'),
 for field, value in matches.iteritems() :
 if value :
 yield field, value.strip()
-HOST_OWNERS = {
+NONE_OWNERS = set((
-u'tech':        'root',
+u'tech',
-u'atk':         'root',
+u'atk',
-u'toimisto':    'root',
+u'toimisto',
-}
+))
-def process_host_owner (options, host, info) :
+def process_host_owner_ldap (options, host, info) :
 """
 Yield guesses for user from LDAP.
 """
-if info.get('owner').lower() in HOST_OWNERS :
-yield HOST_OWNERS[info.get('owner').lower()]
 if info.get('mail') :
 for user in options.ldap.users.filter(
 { 'mailLocalAddress': info['mail'] },
 { 'uid': info['mail'] },
 ) :
-yield user['uid']
+yield user, None
 if info.get('group') and info.get('owner') :
 groups = options.ldap.groups.filter(cn=info['group'])
 for group in groups :
 for user in options.ldap.users.filter({
 'gidNumber': group['gidNumber'],
 'cn': info['owner'],
 }) :
-yield user['uid']
+yield user, group
 if info.get('owner') :
 for user in options.ldap.users.filter({
 'cn': info['owner'],
 }) :
-yield user['uid']
+yield user, None
+def process_host_owner (options, host, info) :
+"""
+Return (owner, comment) for host based on info, or None.
+"""
+if info.get('owner').lower() in NONE_OWNERS :
+return
+# from ldap?
+for ldap in process_host_owner_ldap(options, host, info) :
+user, group = ldap
+if not group :
+# get group from ldap
+group = options.ldap.users.group(user)
+return user['uid'], u"{group} / {user}".format(
+user    = user.getunicode('cn'),
+group   = group.getunicode('cn'),
+)
 def process_host_comments (options, host, info) :
 """
 Process host fields from comment.
 Attempts to find owner from LDAP..
 """
 log.debug("%s: %s", host, info)
-for owner in process_host_owner(options, host, info) :
+owner = process_host_owner(options, host, info)
-log.info("%s: %s", host, owner)
+if owner :
+owner, comment = owner
+log.info("%s: %s (%s)", host, owner, comment)
+yield 'owner-comment', comment
 yield 'owner', owner,
-# only use the first match
-break
 else :
 log.warn("%s: no owner: %s", host, info)
 if info.get('host') :
 yield 'comment', info['host']
 ).encode('utf-8')
 for field, value in process_host_comments(options, host, fields) :
 yield host, field, value
-def process_hosts_import (options, import_hosts) :
+def apply_hosts_import (options) :
 """
-Import host definitions from given infos
+Import host infos from given files.
 """
+if options.import_zone_hosts:
+for info in import_zone_hosts(options,
+pvl.args.apply_file(options.import_zone_hosts)) :
+yield info
+if options.import_dhcp_hosts:
+for info in import_dhcp_conf(options,
+pvl.args.apply_file(options.import_dhcp_hosts)) :
+yield info
+def import_hosts (options) :
+"""
+Import hosts from dns/dhcp.
+"""
+import_hosts = apply_hosts_import(options)
+import_hosts = process_hosts_comments(options, import_hosts)
+# gather
 hosts = collections.defaultdict(lambda: collections.defaultdict(list))
 for host, field, value in import_hosts :
 hosts[host][field].append(value)
 return hosts.iteritems()
+def select_hosts_ip (options, hosts, network) :
+for host, fields in hosts :
+ip = fields.get('ip')
+if not ip :
+continue
+ip = ipaddr.IPAddress(ip[0])
+if ip in network :
+yield ip, host, fields
+def export_hosts (options, hosts) :
+"""
+Export hosts to file.
+"""
+file = pvl.args.apply_file(options.output_hosts, 'w', options.output_charset)
+if options.output_ip :
+prefix = ipaddr.IPNetwork(options.output_ip)
+# filter + sort
+hosts = [(host, fields) for ip, host, fields in sorted(select_hosts_ip(options, hosts, prefix))]
+for host, fields in hosts :
+for comment in fields.get('comment', ()) :
+print >>file, u"# {comment}".format(comment=comment)
+print >>file, u"[{host}]".format(host=host)
+for field, fmt in (
+('ip',              None),
+('ethernet',        None),
+('owner',           u"\t{field:15} = {value} # {fields[owner-comment][0]}"),
+) :
+if not fmt :
+fmt = u"\t{field:15} = {value}"
+for value in fields.get(field, ()) :
+print >>file, fmt.format(field=field, value=value, fields=fields)
+print >>file
 def main (argv) :
 options, args = parse_options(argv)
 options.ldap = pvl.ldap.args.apply(options)
 if args :
 # direct from file
 hosts = pvl.args.apply_files(args, 'r', options.input_charset)
 else :
 # import
-import_hosts = apply_hosts_import(options)
+hosts = import_hosts(options)
-import_hosts = process_hosts_comments(options, import_hosts)
-hosts = process_hosts_import(options, import_hosts)
 # output
 if options.output_hosts :
-for host, fields in hosts :
+export_hosts(options, hosts)
-print host
-for field, values in fields.iteritems() :
-for value in values :
-print "\t", field, "\t", value.encode(options.output_charset)
-return 0
 if __name__ == '__main__':
 pvl.args.main(main)

changeset 263	5ee3bcd5b4b5
parent 262	36c980a6d04a
child 264	ce29be46f705