root/ossiedev/branches/jsnyder/trunk/tools/cornetApps/DomainMan/views.py @ 11103

from django.shortcuts import render_to_response
from django.http import HttpResponse, Http404
from django.template import RequestContext
from paramiko import SSHClient, AutoAddPolicy
from models import *
from WebDash.views import index2

"""
Views for DomainMan application
Starts and stops nodeBooter/naming service through paramiko
"""

"""
Checks if running locally or on the web by testing which Django settings are used
"""
def isOnWeb():
    if environ['DJANGO_SETTINGS_MODULE'] == 'cornetApps.settingsWeb':
        return 1
    if environ['DJANGO_SETTINGS_MODULE'] == 'cornetApps.settings':
        return 0
    
"""
Connects to a server through a given ip, port and associated username and password 
Returns the SSHClient connected to the server
"""
def connect(ip, port, user, password):
    client = SSHClient()
    client.set_missing_host_key_policy(AutoAddPolicy())
    try:
        client.connect(ip, int(port), user, password)
    except:
        raise Http404(u'Incorrect username and password combination')
    return client

"""
Connects to a node given its floor and number
Returns the SSHClient connected to the server
@param floor The floor of the node to connect to
@param num The number of the node to connect to
@param user The username to login with
@param password The password of the user to login with
@return The SSHClient connected to the server
"""
def connectViaNode(floor, num, user, password):
    floor = int(floor)
    num = int(num)
    node = Node(floor, num)
    ip = node.ip
    port = node.port
    client = SSHClient()
    client.set_missing_host_key_policy(AutoAddPolicy())
    try:
        client.connect(ip, int(port), user, password)
    except:
        raise Http404(u'Incorrect username and password combination')
    return client

'''
Tests if nodebooter is running.
@param client: The SSHClient connected to a server/node
@return: A boolean indicating if nodebooter is running
'''
def nodeBooter_running(client):
    stdin, stdout, stderr = client.exec_command('ps -aux | grep GPP')
    processes = stdout.readlines()
    
    #processes = processes.split()
    
    for proc in processes:
        #print 'proc: ' + str(proc)
        #if '/usr/local/bin/nodeBooter' in proc or '/usr/bin/nodeBooter' in proc or 'nodeBooter' in proc:
        if 'dev/bin/GPP' in proc:
            return 1
    #print 'runningNodebooter: ' + str(runningNodebooter)
#    runningNodebooter = 'dev/nodes/' in processes
    return 0

"""
Starts default nodeBooter at a given ip and port
@param ip: The ip address of the server for the nodes
@param port: The port, typically 22
@param user: The user's username with access to the node
@param password: The user's password
"""
def startNodebooter(request, floor, num, user, password):
    floor = int(floor)
    num = int(num)
    node = Node(floor, num)
    ip = node.ip
    port = node.port
    client = connect(ip, port, user, password)
    #stdin, stdout, stderr = client.exec_command('cd /sdr; nodeBooter -D -d dev/nodes/default_GPP_node/DeviceManager.dcd.xml')
    client.exec_command('cd /sdr ; nodeBooter -D -d dev/nodes/default_GPP_node/DeviceManager.dcd.xml')
    runningNodebooter = nodeBooter_running(client)
    client.close
    return render_to_response('DomainMan/runningNodebooter.html', locals(), context_instance=RequestContext(request))

"""Start nodebooter with premade client from client list
"""
#def startNodebooter(request, floor, number):
#    clientID = str(postFloor).__add__("-").__add__(str(postNum))
#    client = SSHClientList.getClient(clientID)
#    #stdin, stdout, stderr = client.exec_command('cd /sdr; nodeBooter -D -d dev/nodes/default_GPP_node/DeviceManager.dcd.xml')
#    client.exec_command('cd /sdr; nodeBooter -D -d dev/nodes/default_GPP_node/DeviceManager.dcd.xml')
#    runningNodebooter = nodeBooter_running(client)
#    return render_to_response('DomainMan/runningNodebooter.html', locals(), context_instance=RequestContext(request))

"""Choose a device manager from a populated list
"""
def getDomainManagerCommand():
    return

"""
Populate the list of device managers from a given node
@param floor The floor of the node to connect to
@param num The number of the node to connect to
@param user The username to login with
@param password The password of the user to login with
@return An array of the list of device managers on the node
"""
def getDeviceManagers(floor, num, user, password):
    client = connectViaNode(floor, num, user, password)
    stdin, stdout, stderr = client.exec_command('cd /sdr; ls --format single-column dev/nodes/')
    #stdin, stdout, stderr = client.exec_command('cd /sdr; ls')
    client.close
    return stdout.readlines()
 
"""
View for displaying device and domain managers
@param request The Django request parameter for views
@param floor The floor of the node to connect to
@param num The number of the node to connect to
@param user The username to login with
@param password The password of the user to login with
@return HttpResponse object with template and local context dictionary or
    Http404 if could not find user and password session variables
"""
def manager_view(request, floor, num, user, password):
    deviceManagers = getDeviceManagers(floor, num, user, password)
    try:
        request.session["user"] = user
        request.session["password"] = password
    except:
        raise Http404(u'Could not set user and password in session variables')
    if len(deviceManagers) == 0:
        message = "No device managers on this node"
    floors = range(1,5)
    nodes = range(1,13)
    return render_to_response('DomainMan/managers.html', locals(), context_instance=RequestContext(request))

"""
Start a device manager and a domain manager
checks post and session variables.
execute command based domain and device manager options
@param request The Django request parameter for views
@return HttpResponse object with template and local context dictionary or
    Http404 if could not find user and password session variables
"""
def startManager(request):
    if 'floor' in request.POST and 'node' in request.POST:
        if request.session.get('user') and request.session.get('password'):
            sessionUser = request.session.get('user')
            sessionPass = request.session.get('password')
        else:
            raise Http404(u'Could not get session user and password')
        floor = int(request.POST['floor'])
        node = int(request.POST['node'])
        user = str(sessionUser)
        password = str(sessionPass)
        client = connectViaNode(floor, node, user, password)
    else:
        raise Exception('client could not connect with POST variables')
    
    domain = getDomain(request)
    device = getDeviceXML(request)
    domainIP = getDomainIP(request)
    
    command = "cd /sdr; nodeBooter "+domain+" "+device+" "+domainIP
    print command
    client.exec_command(command)
    client.close
    return render_to_response('DomainMan/runningNodebooter.html', {'command' : command}, context_instance=RequestContext(request))

"""
Gets the parameters to run domain manager
@param request The Django request parameter for views
@return The correct command based on the domainLocation session variable
    -D if the domain manager is located on the same node
    nothing if the domain manager is located on a remote node
"""
def getDomain(request):
    if 'domainLocation' in request.POST:
        if request.POST['domainLocation'] == 'same':
            domain = "-D"
        elif request.POST['domainLocation'] == 'remote':
            domain = ""
    else:
        raise Http404(u'Could not get domain location from POST Request')
    return domain

"""
Gets the device manager's xml file to run based on a given POST request
@param request The Django request parameter for views
@return The string command for the device manager xml file
    returns Http404 if cannot find the device parameter in the post request
"""
def getDeviceXML(request):
    if 'deviceManager' in request.POST:
        if 'device' in request.POST:
            deviceName = str(request.POST['device'])
        else:
            raise Http404(u'Could not get device manager name from POST request')
        #rstrip removes the trailing \n character
        deviceXML = "-d dev/nodes/"+deviceName.rstrip()+"/DeviceManager.dcd.xml"
    else:
        raise Http404(u'DeviceManager not selected in POST request')
    return deviceXML

"""
Sets up the domain manager ip address to run based on a given POST request
@param request The Django request parameter for views
@return The domain string options using the -ORBInitRef and ip address using corba
"""
def getDomainIP(request):
    if 'domain' in request.POST and 'floor' in request.POST and 'node' in request.POST:
        if request.POST['domainLocation'] == 'remote':
            floor = int(request.POST['floor'])
            num = int(request.POST['node'])
            node = Node(floor, num)
            domainIP = "-ORBInitRef NameService=corbaname::"+node.ip
        elif request.POST['domainLocation'] == 'same':
            domainIP = ""
    else:
        raise Http404(u'POST request does not have a floor and node number')
    return domainIP

"""Kills all nodeBooter processes at a given ip and port
@param ip: The ip address of the server for the nodes
@param port: The port, typically 22
@param user: The user's username with access to the node
@param password: The user's password
"""
def stopNodebooter(request, floor, num, user, password):
    floor = int(floor)
    num = int(num)
    node = Node(floor, num)
    ip = node.ip
    port = node.port
    client = connect(ip, port, user, password)   
    stdin, stdout, stderr = client.exec_command('killall nodeBooter && killall GPP')
    runningNodebooter = nodeBooter_running(client)
    client.close
    return render_to_response('DomainMan/runningNodebooter.html', locals(), context_instance=RequestContext(request))

'''
Testing view to check if nodebooter is running.
Checks if nodeBooter is running, if not, starts it.
@param ip: The ip address of the server for the nodes
@param port: The port, typically 22
@param user: The user's username with access to the node
@param password: The user's password
@return HttpResponse with local variables as a context dictionary inserted into the console.html template
'''
def nodeBooter_page(request, ip, port, user, password):
    if 'ip' in request.POST and 'port' in request.POST and 'user' in request.POST and 'pass' in request.POST:
        client = connect(ip, port, user, password)
    else:
        raise Exception('client could not connect with POST variables')
    if not nodeBooter_running(client):
        stdin, stdout, stderr = client.exec_command('cd /sdr; nodeBooter -D -d dev/nodes/default_GPP_node/DeviceManager.dcd.xml')
    runningNodebooter = nodeBooter_running(client)
    client.close
    return render_to_response('DomainMan/console.html', locals(), context_instance=RequestContext(request))



"""
Connect to a node through post variables
@param request Contains the post variables floor, number, user, and pass to connect to a node
@return The local variables as dictionary into the DomainMan/runningNodebooter.html template
    If one of the post variables are not there, it will print a "Missing ssh connection parameters" string
"""
def connect_to_node(request):
    if 'floor' in request.POST and 'number' in request.POST and 'user' in request.POST and 'pass' in request.POST:
        floor = int(request.POST['floor'])
        num = int(request.POST['number'])
        user = str(request.POST['user'])
        password = str(request.POST['pass'])
        
        node = Node(floor, num)
        ip = node.ip
        port = node.port
        client = connect(ip, port, user, password)
        runningNodebooter = nodeBooter_running(client)
        client.close
    else:
        message = 'Missing ssh connection parameters'
        print message
    return render_to_response('DomainMan/runningNodebooter.html', locals(), context_instance=RequestContext(request))

"""
Raise exception if the inputs of the floor and node number are invalid
@param floor The given floor to check
@param num The given node number to check
@return Exception if the floor or node num is less than 1 or greater than 4 or 12, respectively
"""
def testValidInputs(floor, num):
    if floor < 1 or floor > 4:
        raise Exception("Floor must be between 1 and 4")
    if num < 1 or num > 12:
        raise Exception("Node must be between 1 and 12")

#@login_required
"""
Loads the DomainMan/nodes.html template based on a logging into a specific node
@param floor_num The floor of the node to login to
@param node_num The node number of the node to login to
@return The HttpResponse object with the local variables added to the dictionary
"""
def loadNode(request, floor_num, node_num):
    floor = int(floor_num)
    num = int(node_num)
    testValidInputs(floor, num)
    node = Node(floor, num)
    ip = node.ip
    port = node.port
    if isOnWeb():
        address = str(ip) + ":" + str(port)
    else:
        address = str(ip)
    #index2(request, ip)
    return render_to_response("DomainMan/nodes.html", locals(), context_instance=RequestContext(request))

"""
Returns connection form
@param selectFloor The floor of the node to login to
@param selectNum The node number of the node to login to
@return the HttpResponse object with the local variable dictionary in the DomainMan/connect.html template
"""
def connect_to_node_view(request, selectFloor, selectNum):
    number_of_floors = range(1,5)
    number_of_nodes = range(1,13)
    selectedFloor=int(selectFloor)
    selectedNum=int(selectNum)
    testValidInputs(selectedFloor, selectedNum)
    return render_to_response('DomainMan/connect.html', locals(), RequestContext(request))