# $Id$
# $URL$

"""
Scan the VINI Central database and create topology "rspec" attributes for
slices that have an EGRE key.  This script to be run from a cron job.
"""

import string
import socket

"""
Links in the physical topology, gleaned from looking at the Internet2
and NLR topology maps.  Link (a, b) connects sites with IDs a and b.
"""
links = [(2, 12),  # I2 Princeton - New York 
         (4, 5),   # NLR Chicago - Houston
         (4, 6),   # NLR Chicago - Atlanta
         (4, 7),   # NLR Chicago - Seattle
         (4, 9),   # NLR Chicago - New York
         (4, 10),  # NLR Chicago - Wash DC
         (5, 6),   # NLR Houston - Atlanta
         (5, 8),   # NLR Houston - Los Angeles
         (6, 10),  # NLR Atlanta - Wash DC
         (7, 8),   # NLR Seattle - Los Angeles
         (9, 10),  # NLR New York - Wash DC
         (11, 13), # I2 Chicago - Wash DC
         (11, 15), # I2 Chicago - Atlanta
         (11, 16), # I2 Chicago - CESNET
         (11, 17), # I2 Chicago - Kansas City
         (12, 13), # I2 New York - Wash DC
         (13, 15), # I2 Wash DC - Atlanta
         (15, 19), # I2 Atlanta - Houston
         (17, 19), # I2 Kansas City - Houston
         (17, 22), # I2 Kansas City - Salt Lake City
         (19, 20), # I2 Houston - Los Angeles
         (20, 21), # I2 Los Angeles - Seattle
         (20, 22), # I2 Los Angeles - Salt Lake City
         (21, 22)] # I2 Seattle - Salt Lake City


"""
Generate site adjacency map from list of links
"""
def gen_adjacencies(links):
    adj = {}
    for (a, b) in links:
        if a in adj:
            adj[a].append(b)
        else:
            adj[a] = [a, b]
        if b in adj:
            adj[b].append(a)
        else:
            adj[b] = [b, a]
    return adj


"""
Test whether two sites are adjacent to each other in the adjacency graph.
"""
def is_adjacent(adjacencies, s1, s2):
    set1 = set(adjacencies[s1])
    set2 = set(adjacencies[s2])

    if s1 in set2 and s2 in set1:
        return True
    elif not s1 in set2 and not s2 in set1:
        return False
    else:
        raise Exception("Adjacency mismatch, sites %d and %d." % (s1, s2))


"""
Check the adjacency graph for discrepancies.
"""
def check_adjacencies(adjacencies):
    for site in adjacencies:
        for adj in adjacencies[site]:
            try:
                test = is_adjacent(adjacencies, site, adj)
            except Exception, e:
                print "Error: ", e, " Fix adjacencies!"
    return


def get_site(nodeid):
    if nodes[nodeid]:
        return nodes[nodeid]['site_id']
    raise Exception("Nodeid %s not found." % nodeid)


def get_ipaddr(nodeid):
    if nodes[nodeid]:
        return socket.gethostbyname(nodes[nodeid]['hostname'])
    raise Exception("Nodeid %s not found." % nodeid)


def get_sitenodes(siteid):
    if sites[siteid]:
        return sites[siteid]['node_ids']
    raise Exception("Siteid %s not found." % siteid)


"""
Find the IP address assigned to a virtual interface in the topology
(for creating /etc/hosts)
"""
def get_virt_ip(myid, nodeid):
    if myid < nodeid:
        virtip = "10.%d.%d.2" % (myid, nodeid)
    else:
        virtip = "10.%d.%d.3" % (nodeid, myid)
    return virtip


"""
Create a dictionary of site records keyed by site ID
"""
def get_sites():
    tmp = []
    for site in GetSites():
        t = site['site_id'], site
        tmp.append(t)
    return dict(tmp)


"""
Create a dictionary of node records keyed by node ID
"""
def get_nodes():
    tmp = []
    for node in GetNodes():
        t = node['node_id'], node
        tmp.append(t)
    return dict(tmp)

adjacencies = gen_adjacencies(links)    
check_adjacencies(adjacencies)

""" Need global topology information """
sites = get_sites()
nodes = get_nodes()

for slice in GetSlices():
    """ Create dictionary of the slice's attributes """
    attrs ={}
    topo_attr = {}
    for attribute in GetSliceAttributes(slice['slice_attribute_ids']):
        attrs[attribute['name']] = attribute['slice_attribute_id']
        if attribute['name'] == 'topo_rspec' and attribute['node_id']:
            topo_attr[attribute['node_id']] = attribute['slice_attribute_id']
            
    if 'egre_key' in attrs:
        #print "Virtual topology for %s:" % slice['name']
        slicenodes = set(slice['node_ids'])
        hosts = "127.0.0.1\t\tlocalhost\n"
        """
        For each node in the slice, check whether nodes at adjacent sites
        are also in the slice's node set.  If so, add a virtual link to 
        the rspec.  
        """
        for node in slicenodes:
            topo = []
            for adj in adjacencies[get_site(node)]:
                for adj_node in get_sitenodes(adj):
                    if node != adj_node and adj_node in slicenodes:
                        link = adj_node, get_ipaddr(adj_node), "1Mbit"
                        topo.append(link)
                        shortname = nodes[node]['hostname'].replace('.vini-veritas.net', '')
                        hosts += "%s\t\t%s\n" % (get_virt_ip(node, adj_node),
                                                  shortname)
            topo_str = "%s" % topo
            #print node, topo_str
            if node in topo_attr:
                UpdateSliceAttribute(topo_attr[node], topo_str)
                del topo_attr[node]
            else:
                id = slice['slice_id']
                AddSliceAttribute(id, 'topo_rspec', topo_str, node)

        #print hosts
        if 'hosts' in attrs:
            UpdateSliceAttribute(attrs['hosts'], hosts)
        else:
            id = slice['slice_id']
            AddSliceAttribute(id, 'hosts', hosts)
    #else:
        #print "No EGRE key for %s" % slice['name']

    """ Remove old topo_rspec entries """
    for node in topo_attr:
        DeleteSliceAttribute(topo_attr[node])