hostinfo.py

#!/usr/bin/python

import copy
import hostinfo.automount
import hostinfo.dhcpd
import hostinfo.ifconfig
import hostinfo.macosx_auto
import hostinfo.mio
import hostinfo.named
import hostinfo.parser
import hostinfo.pxelinux
import hostinfo.samba
import hostinfo.yp
import hostinfo.role
import optparse
import os
import sys

"""
  This program parses hostinfo.xml files. The following tags/attribute
  structure is currently used:

  <hostinfo             -- Top level tag
    modification_time   -- Syntetic attribute (.xml mtime)
  >
    <soa                -- SOA info for named files
       domain           -- SOA domain (all if not set)
       nameserver       -- primary nameserver for domain
       email            -- email for domain
       ttl              -- default TTL for SOA
       refresh          -- refresh interval
       retry            -- retry interval
       expire           -- expire interval
       minimum          -- minimum interval
    />
    <subnet             -- subnet information (named, dhcpd)
       broadcast        -- broadcast address for subnet
       domain           -- subnet domain name
       name_servers     -- subnet nameservers
       netmask          -- subnet netmask
       network          -- subnet network
       routers          -- subnet routers
    />
    <host               -- host specific information
       info             -- catchall for useful info
       name             -- hostname (FQN if ends with .)
    >
      <interface        -- host interface information
          ethernet      -- ethernet address
          ip            -- ip address
          name          -- optional name for this ip address
      >
        <dhcpserver     -- interface serves as a dhcpserver
        />
        <nameserver
           domain       -- interface is nameserver for this domain
        <kickstart
           file         -- kickstart file to use
        />
        <alias
           name         -- alias for this interface
        <dhcp
          value         -- extra dhcp data for host
        />
      </interface>
    </host>

  </hostinfo>
"""

# Fix for older python version that does not have True and False defined
if not hasattr(__builtins__, "True"):
    __builtins__["True"] = 1
    __builtins__["False"] = 0

class VerboseOptionParser(optparse.OptionParser):
    def error(self, msg):
        self.print_help()
        optparse.OptionParser.error(self, msg)

attr_weight = {
    ('host', 'name') : 1,
    ('interface', 'ip') : 1,
    ('interface', 'ether') : 2,
    ('subnet', 'network') : 1,
    ('subnet', 'domain') : 2,
    ('subnet', 'broadcast') : 3,
    ('subnet', 'netmask') : 4,
    ('subnet', 'gateway') : 5,
    ('subnet', 'name_servers') : 6,
}

#def cmp(a,b):
#    if a < b:
#        return -1
#    elif a == b:
#        return 0
#    else:
#        return 1

def host_order(a,b):
    def at_top(n):
        # Place hosts without ethernet or ip address at top
        for i1 in n._interface_:
            if i1.ethernet[0]:
                return False
            for i2 in i1._ip_:
                if i2.address[0]:
                    return False
                pass
            pass
        return True
    def at_bottom(n):
        # Place hosts with ethernet but without ip address at bottom
        result = False
        for i1 in n._interface_:
            if i1.ethernet[0]:
                result = True
            for i2 in i1._ip_:
                if i2.address[0]:
                    return False
                pass
            pass
        return result
    if (at_top(a) == at_top(b) and at_bottom(a) == at_bottom(b)):
        return cmp(a.name[0], b.name[0])
    elif at_top(a):
        return -1
    elif at_top(b):
        return 1
    elif at_bottom(a):
        return 1
    elif at_bottom(b):
        return -1
    else:
        raise Exception('Should never happen')

tag_weight = {
    ('hostinfo', 'soa')        : (1,
                                  None),
    ('hostinfo', 'subnet')      : (2,
                                   lambda a,b: cmp(a.network[0],b.network[0])),
    ('hostinfo', 'netgroup')    : (3,
                                   lambda a,b: cmp(a.name[0],b.name[0])),
    ('hostinfo', 'host')        : (4,
                                   host_order),
    ('host', 'automount')       : (1,
                                   lambda a,b: cmp(a.host[0],b.host[0])),
    ('host', 'mio')             : (2,
                                   None),
    ('interface', 'kickstart')  : (1,
                                   None),
    ('interface', 'ip')         : (2,
                                   None),
    ('interface', 'alias')      : (3,
                                   None),
    ('interface', 'dhcpserver') : (4,
                                   None),
    ('interface', 'nameserver') : (5,
                                   None),
    ('automount', 'entry')      : (1,
                                   lambda a,b: cmp(a.key[0],b.key[0])),
}

def attr_sort(node, a, b):
    try:
        aw = attr_weight[node._tag, a]
    except:
        aw = 0

    try:
        bw = attr_weight[node._tag, b]
    except:
        bw = 0

    if aw and bw:
        return cmp(aw, bw)
    elif aw:
        return -1
    elif bw:
        return 1
    else:
        return cmp(a, b)

def tag_sort(parent, a, b):
    try:
        (aw, sort) = tag_weight[parent._tag, a._tag]
    except:
        aw = 0

    try:
        (bw, sort) = tag_weight[parent._tag, b._tag]
    except:
        bw = 0

    if aw and bw:
        if aw == bw and sort:
            return sort(a,b)
        else:
            return cmp(aw, bw)
    elif aw:
        return -1
    elif bw:
        return 1
    else:
        return None

if __name__ == '__main__':
    optParser = VerboseOptionParser(usage="%prog [options] [hostinfo]")
    optParser.add_option("--host",
                         action="store", 
                         help="The host to generate information for")
    optParser.add_option("--automount",
                         action="store",  metavar="DIR",
                         help="generate automount maps in DIR")
    optParser.add_option("--auto_domain",
                         action="store",  metavar="DOMAIN",
                         help="DOMAIN name for automount maps")
    optParser.add_option("--dfs",
                         action="store",  metavar="DIR",
                         help="generate DIR/*/(dfslink|autolink)")
    optParser.add_option("--dhcpd",
                         action="store",  metavar="DIR",
                         help="generate DIR/dhcpd.conf file")
    optParser.add_option("--ethers",
                         action="store", metavar="FILE",
                         help="Generate ethers FILE")
    optParser.add_option("--ifconfig",
                         action="store", metavar="DIR",
                         help="Generate DIR/ifcfg-eth*")
    optParser.add_option("--kickstart",
                         action="store",  metavar="DIR",
                         help="kickstart files should be fetched from DIR")
    optParser.add_option("--macosx_auto",
                         action="store", metavar="DIR",
                         help="Generate MacOSX autmount maps")
    optParser.add_option("--mio",
                         action="store_true", default=False, 
                         help="output mio tree")
    optParser.add_option("--named",
                         action="store", metavar="DIR",
                         help="Generate DIR/named.conf and DIR/named/*")
    optParser.add_option("--netgroup",
                         action="store", metavar="FILE",
                         help="Generate netgroup FILE")
    optParser.add_option("--next_server",
                         action="store", metavar="HOST",
                         help="Use HOST as DHCP next-server")
    optParser.add_option("--pretty",
                         action="store_true", default=False, 
                         help="pretty-print XML tree")
    optParser.add_option("--pxelinux",
                         action="store",  metavar="DIR", 
                         help="symlink DIR/<ethernet> to <kickstart>")
    optParser.add_option("--role",
                         default=[],
                         action="append",  metavar="ROLE", 
                         help="check if machine has ROLE")
    optParser.add_option("--samba",
                         action="store",  metavar="FILE",
                         help="generate samba share FILE")
    optParser.add_option("--yp",
                         action="store",  metavar="DIR",
                         help="generate DIR/{hosts,ethers,etc} information")
    optParser.add_option("--yp_auto_domain",
                         action="store",  metavar="DOMAIN",
                         help="DOMAIN name for yp automounter maps")

    (options, args) = optParser.parse_args(sys.argv[1:])

    
    host = options.host or os.uname()[1].split('.')[0]

    if not args:
        tree = hostinfo.parser.parse("/etc/hostinfo.xml")
    elif len(args) == 1:
        tree = hostinfo.parser.parse(args[0])
    else:
        raise Exception("Only one hostinfo file allowed")
    
    file = {}
    symlink = {}
    if options.dfs:
        for (f, c) in hostinfo.samba.msdfs(tree):
            symlink["%s/%s" % (options.dfs, f)] = c

    if options.automount:
        for (f, c) in hostinfo.automount.generate(tree,options.auto_domain):
            file["%s/%s" % (options.automount, f)] = c

    if options.dhcpd:
        name = "%s/dhcpd.conf" % options.dhcpd
        if options.kickstart:
            kickstart = os.path.abspath(options.kickstart)
        else:
            kickstart = None
            pass
        file[name] = hostinfo.dhcpd.conf(tree, host, kickstart,
                                         next_server=options.next_server)
    
    if options.ethers:
        file[options.ethers] = hostinfo.yp.ethers(tree)

    if options.ifconfig:
        for (f, c) in hostinfo.ifconfig.generate(tree, host):
            file["%s/%s" % (options.ifconfig, f)] = c
        
    if options.macosx_auto:
        for (f, c) in hostinfo.macosx_auto.generate(tree):
            file["%s/%s" % (options.macosx_auto, f)] = c
        
    if options.mio:
        mio = hostinfo.mio.generate(tree)
        print mio.encode("iso8859-1")
        
    if options.named:
        for (f, c) in hostinfo.named.generate(tree, host):
            file["%s/%s" % (options.named, f)] = c

    if options.netgroup:
        file[options.netgroup] = hostinfo.yp.netgroup(tree)

    if options.pxelinux:
        ksinfo = ""
        for (mac, host, ksfile) in hostinfo.pxelinux.generate(tree, host):
            ksinfo += "%s %s %s\n" % (mac, host, ksfile)
            # symlink["%s/%s" % (options.pxelinux, mac)] = ksfile
        file["%s/ksinfo" % options.pxelinux] = ksinfo
            
    if options.pretty:
        result = "<?xml version='1.0' encoding='utf-8'?>\n\n"
        result += tree._xml(attr_sort=attr_sort, tag_sort=tag_sort)
        print result.encode("utf-8")

    if options.role:
        roles = hostinfo.role.generate(tree, host, options.role)
        # print "Roles:",",".join(roles)
        sys.exit(len(roles) != len(options.role))
        
    if options.yp:
        for (f, c) in hostinfo.yp.generate(tree, options.yp_auto_domain):
            file["%s/%s" % (options.yp, f)] = c

    if options.samba:
        file[options.samba] = hostinfo.samba.share(tree, host)

    result = 1
    for name in file.keys():
        write = False
        try:
            f = open(name)
            conf = f.read()
            f.close()
            write = conf != file[name].encode("iso8859-1")
        except IOError, e:
            write = True

        if write:
            print name
            result = 0
            f = open(name, "w")
            f.write(file[name].encode("iso8859-1"))
            f.close()

    for name in symlink.keys():
        if os.path.lexists(name) and not os.path.islink(name):
            print "'%s' exists but is not a link" % name
        elif not os.path.lexists(name):
            print "Creating '%s' -> '%s'" % (name, symlink[name])
            os.symlink(symlink[name], name)
            result = 0
        elif os.readlink(name) != symlink[name]:
            print "Changing '%s' -> '%s'" % (name, symlink[name])
            os.unlink(name)
            os.symlink(symlink[name], name)
            result = 0

    sys.exit(result)