discovery.py

import pdb
import subprocess

from netaddr import *
from neutronclient.v2_0 import client
import novaclient.v1_1.client as nvclient

from credentials import get_credentials,get_tenant_nova_credentials

from vm_instances import discover_vm_on_network,launch_vm_on_network,vm_endpoint_discovery
from networks import delete_networks,delete_vm
credentials = get_credentials()
neutron = client.Client(**credentials)
tenant_data=[]
router_data=[]
network_dict={}
network_data=[]

def tenant_discovery():
    pdb.set_trace()
    tenant_data = [{'id': u'79bb772c47c24744853824305c796ea7','name': u'admin'}]
    network_data=network_discovery(tenant_data)
    
#   discover_instance(tenant_data)
    #launch_instance(tenant_data,network_data)
    endpoints=endpoint_discovery(tenant_data,network_data)
    print endpoints
#   destroy_all(tenant_data,network_data)

def get_ip_range():

    ips=IPRange("1.1.1.0","1.1.1.254")
    return ips

def endpoint_discovery(tenant_data,network_data):
    pdb.set_trace()
    instance_list=[]
    endpoint_list=[]
    final_data=[]
     
    for tenant in tenant_data:
        print("Get router information")
        routers=get_router(tenant)
        ports=get_ports(tenant)
        instance_ports = get_instance_ports(ports)
        for router in routers:
            router_detail = {}
            router_detail['id'] = router['id']
            router_detail['ports'] = get_router_ports(router, ports)
            subnets = []
            instance_list = []
            for port in router_detail['ports']:
                 
                subnets.append(get_port_subnets(tenant, port))
                router_detail['subnets'] = subnets
                for subnet in router_detail['subnets']:
                    if subnet['id'] != '':
                        endpoint_detail = get_subnet_endpoints(tenant, instance_ports, subnet)
                        ip_list = []
                        subnet['instances'] = endpoint_detail
                        for entry in endpoint_detail:
                            server = get_instance_detail(tenant['name'],entry['device_id'])
                            if entry['device_id'] not in instance_list and \
                               server.status == 'ACTIVE':
                                ips=get_ip_range()
                                ip_list.append(entry['ip_address'])

                                ipset=IPSet(ip_list)
                                for ip in ips:
                                    if ip in ipset:
                                        print("instance %s found"%(entry['ip_address']))
                                        instance_list.append(entry['device_id'])
                                        endpoint_list.append({'endpoints': ip_list,'tenant_name':tenant['name'],'subnet':subnet})

    return endpoint_list

def get_instance_detail(tenant,instance):

    tenant_credentials = get_tenant_nova_credentials(tenant)
    nova = nvclient.Client(**tenant_credentials)
    return nova.servers.get(instance)

def get_router_ports(router,ports):

    router_port_list = []
    for port in ports:
        if (port['device_id'] == router['id'] and
                port['device_owner'] == 'network:router_interface'):
            router_port_list.append(port)
    return router_port_list

def get_port_subnets(tenant,port):

    subnet = get_subnet_detail(tenant, port['fixed_ips'][0]['subnet_id'])['subnet']
    return {'id': port['fixed_ips'][0]['subnet_id'], 'name': subnet['name'],
            'ip_address': port['fixed_ips'][0]['ip_address'],'allocation_pool':subnet['allocation_pools']}

def get_subnet_detail(tenant, subnet):
    
    return neutron.show_subnet(subnet)

def get_subnet_endpoints(tenant,ports,subnet):

    endpoints = []
    for port in ports:
        endpoint_detail = {}
        if port['fixed_ips'][0]['subnet_id'] == subnet['id']:
            device_id = port['device_id'].encode('unicode_escape')
            ip = port['fixed_ips'][0]['ip_address'].encode('unicode_escape')
            endpoint_detail['device_id'] = device_id
            endpoint_detail['ip_address'] = ip
            endpoints.append(endpoint_detail)
    return endpoints


def get_router(tenant):
    routers=neutron.list_routers(tenant_id=tenant['id'])['routers']
    return routers
def get_ports(tenant):
    ports=neutron.list_ports(tenant_id=tenant['id'])['ports']
    return ports

def get_instance_ports(ports):
    pdb.set_trace()
    instance_port_list = []
    for port in ports:
        if port['device_owner'] == 'compute:nova' or port['device_owner'] == 'compute:compute' :
            instance_port_list.append(port)
    return instance_port_list

def destroy_all(tenant_data,network_data):

    delete_vm(tenant_data,network_data)
    delete_networks(tenant_data,network_data)
    
def network_discovery(tenant_data):
    pdb.set_trace()
    network_detail=[]
    subnet_detail=[]
    instance_list=[]
    net_sub={}
    for tenant in tenant_data:
        
        networks=neutron.list_networks(tenant_id=tenant['id'])['networks']


# List all subnets under each network and the tenants
        for net in networks:
            nets={}
            if net['tenant_id'] == tenant['id']:
                nets={'network_list':{'tenant_name':tenant['name'],
                                      'network_name':net['name'],'network_id':net['id'],'shared':net['shared'],'subnets':net['subnets']}}
                subnets=neutron.list_subnets(network_id=net['id'])['subnets']
                for subnet in subnets:
                    #net_sub={'networks':{'tenant_name':tenant['name'],'network_name':net['name'],'network_id':net['id'],'shared':net['shared']},'subnets':{'subnet_name':subnet['name'],'cidr':subnet['cidr']}}
                    net_sub={'networks':{'tenant_name':tenant['name'],'network_name':net['name'],'network_id':net['id'],'shared':net['shared'],'subnet_name':subnet['name'],'cidr':subnet['cidr']}}

                    subnet_detail.append(net_sub)
                    print "\n"
                    print "List subnets along with network details"
                    print "tenant name %s"%(tenant['name'])
                    print "network_name %s"%(net['name'])
                    print "subnet_name %s"%(subnet['name'])
                    print "cidr\t %s"%(subnet['cidr'])
                    print "allocation pools...%s"%(subnet['allocation_pools'])
                    print "\n"

                network_detail.append(nets)

    return network_detail
        
def launch_instance(tenant_data,network_data):
    #pdb.set_trace()
    inst_data=[]
    count=1
    for tenant in tenant_data:
        
        for network in network_data:
            pdb.set_trace()
            vm_name=tenant['name'] + '-vm-' + str(count)
            if ((network['network_list']['tenant_name'] == tenant['name']) and (network['network_list']['shared'] == True)):
                
                inst_data.append(launch_vm_on_network(tenant['name'],vm_name,network['network_list']['network_id']))

                count += 1

def discover_instance(tenant_data):
    instance_detail=[]
    pdb.set_trace()
    for tenant in tenant_data:
        
        vm_dict={}
        instance_detail.append(discover_vm_on_network(tenant['name']))
    print instance_detail     
        
        
def router_discovery(tenant_data):
    #pdb.set_trace()
    for tenant in tenant_data:
        #router_dict = {}
        router=neutron.list_routers(tenant_id=tenant['id'])['routers']
        for route in router:

            router_dict={}
            #for rout in router:
            
            if  route['tenant_id'] == tenant['id']:
                print('   - Router %s Discovered' % route['name'])
                status = True
                router_id = route['id']
                router_dict['tenant_name']=tenant["name"]
                router_dict['router_status'] = status
                router_dict['router_name']=route['name']
                router_data.append(router_dict)

            else:
                print("Tenant %s  not having any router"%(tenant['name']))  
            #if rout['tenant_id'] == tenant['id']:
                #print('   - Router %s Discovered' % rout['name'])
                #status = True
                #router_id = rout['id']
                #router_dict['tenant_name']=tenant["name"]
                #router_dict['router_status'] = status
                #router_dict['router_name']=rout['name']

        else:
            print('   - Router Not Found in %s tenant' % tenant['name'])
            status = False
        #router_id = rout['id']
        #router_dict['router_status'] = status
        #router_data.append(router_dict)

       
        #router_id = router['id']
        #router_dict['router_status'] = status
        #router_data.append(router_dict)
       
    print router_data    

def main():

    tenant_discovery()   







if __name__  == '__main__':

    main()