# $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

"""
Map sites to adjacent sites in topology.  Generated manually :-(
A site is adjacent to itself.
"""
adjacencies = {
    1: [1], 2: [2,12], 3: [3], 4: [4,5,6,7,9,10], 5: [4,5,6,8], 
    6: [4,5,6,10], 7: [4,7,8], 8: [5,7,8], 9: [4,9,10], 10: [4,6,9,10], 
    11: [11,13,15,16,17], 12: [2,12,13], 13: [11,12,13,15], 14: [14], 
    15: [11,13,15,19], 16: [11,16], 17: [11,17,19,22], 18: [18], 
    19: [15,17,19,20], 20: [19,20,21,22], 21: [20,21,22], 22: [17,20,21,22]
    }

"""
Test whether two sites are adjacent to each other in the adjacency graph.
"""
def is_adjacent(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():
    for site in adjacencies:
        for adj in adjacencies[site]:
            try:
                test = is_adjacent(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)


"""
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)

    
check_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.append(attribute['name'])
        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'])
        """
        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)
            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)

    else:
        print "No EGRE key for %s" % slice['name']

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