cpcc

#!/usr/bin/env python

# This file is part of Copernicus
# http://www.copernicus-computing.org/
# 
# Copyright (C) 2011, Sander Pronk, Iman Pouya, Erik Lindahl, and others.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as published 
# by the Free Software Foundation
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.



# This is the main executable, from which all actions are launched. 

import sys
import copy
import subprocess
from getpass import getpass
import textwrap

import cpc.util
from cpc.util import cmd_line_utils
from cpc.network.com.client_response import ResponseError
from cpc.util.conf.conf_base import Conf
from cpc.client.view.cmdline import CmdLine
from cpc.util.exception import ClientError
from cpc.client import ClientMessage
from cpc.network.com.client_response import ProcessedResponse
from cpc.util.version import __version__


def print_usage():
    print "Usage: cpcc [global-options] <command> [command-options]"
    print
    print "Local Client commands"
    print "       cpcc add-server        [-n name] host [port]"
    print "       cpcc list-server"
    print "       cpcc use-server        [server]"
    print 
    print "User related commands"
    print "       cpcc login             username"
    print "       cpcc add-user          username"
    print "       cpcc delete-user       username"
    print "       cpcc grant-access      username"
    print
    print "Project start & stop commands:"
    print "       cpcc projects|p"
    print "       cpcc start             projectname"
    print "       cpcc remove|rm         projectname"
    print
    print "Working project setting and inspection command."
    print "       cpcc cd | set-default  projectname"
    print "       cpcc pwd | get-default projectname"
    print 
    print "Project query commands."
    print "       cpcc list | ls         [instance_name]"
    print "       cpcc get               inst:in|out.ioname"
    print "       cpcc getf              [-f filename] inst:in|out.ioname "
    print "       cpcc info              function_name|module_name"
    print "       cpcc log               instance_name"
    print 
    print "Project manipulation commands."
    print "       cpcc list-modules"
    print "       cpcc import            modulename"
    print "       cpcc instance          function_name instance_name"
    print "       cpcc activate          [item]"
    print "       cpcc deactivate        [item]"
    print "       cpcc connect           inst:out.item inst:in.item"
    print "       cpcc set               inst:in.ioname value"
    print "       cpcc setf              inst:in.ioname filename"
    print "       cpcc transact"
    print "       cpcc commit"
    print "       cpcc rollback"
    print "       cpcc upload            upload.xml"
    print "       cpcc clear-error       [item]"
    print "       cpcc force-rerun       item"
    print ""
    print "Worker and heartbeat monitoring commands."
    print "       cpcc status | s        [project]"
    print "       cpcc queue | q"
    print "       cpcc running | r "
    print "       cpcc heartbeats | h "
    print "       cpcc command-failed    commandID"
    print ""
    print "Server control commands"    
    print "       cpcc stop-server"
    print "       cpcc trust             -all |server-id"
    print "       cpcc connect-server    host [client_secure_port]"
    print "       cpcc revoke            server-id"
    print "       cpcc connected-servers | cs"
    print "       cpcc node-pri          priority host [port]"
    print "       cpcc network"
    print "       cpcc readconf"
    print "       cpcc server-info"
    print "       cpcc ping [server-id]"
    print ""
    print "Project Save and Load commands "
    print "       cpcc save      projectname [project-tar]"
    print "       cpcc load      project-tar projectname"
    print "Other commands "
    print "       cpcc version"
    print ""
    print "Common global options:"
    print "       cpcc [-c bundleFile]"
    sys.exit(1)

# make a copy for later
args=copy.copy(sys.argv)

if len(args)<2:
    cmd_line_utils.printLogo()
    cmd_line_utils.printAuthors()
    print_usage()

# remove the 0th argument
args.pop(0)
bundleFile=None

debug=False
# first parse common options
while len(args)>0:
    if args[0][0]!='-':
        break
    elif args[0]=='-c':
        option = args.pop(0)
        if len(args) < 1:
            sys.stdout.write("ERROR: no value specified for global option '%s'\n"%
                             option)
            print_usage()
        bundleFile=args.pop(0)
    elif args[0]=='-d':
        args.pop(0)
        debug=True

    #can only handle the flag here and we do not want to completely rewrite the cmd line parsing logic at the moment
    elif args[0]=='-h':
        print_usage()
        exit(0)
    else:
        sys.stdout.write("ERROR: no command, or erroneous global option '%s'\n"%
                         args[0])
        print_usage()

def _printErrorAndExit(ErrorString):
    sys.stderr.write('%s\n'%ErrorString)
    sys.exit(1)

def getArg(arglist, argnr, name):
    """Get argument, or print out argument description."""
    try: 
        ret=arglist[argnr]
    except IndexError:
        raise ClientError("Missing argument: %s"%name)
    return ret



def getProjectArgs(args):
    """Get argument list for project-style commands, where 
       the project name is optional. Returns a tuple
       of (projectName, options). Options is a list of 
       arguments, without the project name."""
    prevArg=None
    projectName=None
    retArgs=[]
    for arg in args:
        if prevArg == "-p":
            projectName=arg
        elif arg != "-p":
            retArgs.append(arg)          
        prevArg=arg
    if prevArg == "-p":
        raise ClientError("Missing project name")
    return (projectName, retArgs)
        
    

# now parse command and execute it.
#clnt=cpc.client(cf, args)

if len(args)>0:
    cmd=args[0]
else:
    _printErrorAndExit("ERROR: no command")

try:
    # handle local commands
    if cmd == "add-server":
        host=getArg(args, 1, "host")
        project, pargs = getProjectArgs(args)
        if host == '-n':
            name = getArg(args, 2, "servername")
            host = getArg(args, 3, "host")
            if len(pargs) == 4:
                port = Conf.getDefaultClientSecurePort()
            else:
                port = getArg(args, 4, "port")
        else:
            name = host
            if len(pargs) == 2:
                port = Conf.getDefaultClientSecurePort()
            else:
                port = getArg(args, 2, "port")
        cmd_line_utils.addServer(name, host, port)
        sys.exit(0)

    elif cmd == "use-server":
        name = getArg(args, 1, "servername")
        cmd_line_utils.useServer(name)
        sys.exit(0)

    elif cmd == "list-server":
        CmdLine.listServer(cmd_line_utils.listServer())
        sys.exit(0)

    elif cmd == "help":
        print_usage()
        sys.exit(0)

    # Get the client
    if bundleFile is not None:
        conf = cmd_line_utils.initiateConnectionBundle(bundleFile)
        clnt=ClientMessage(conf=conf, use_secure_server_port=True)
    else:
        conf = cmd_line_utils.getClientConf()
        clnt=ClientMessage(conf=conf, use_secure_server_port=False)

    # handle remote commands
    if cmd == "login":
        if "-stdin" in args:
            user = getArg(args, 2, "username")
            password = raw_input()
        else:
            user=getArg(args, 1, "username")
            password = getpass()
        #password=getArg(args, 2, "password")
        ProcessedResponse(clnt.loginRequest(user, password)).pprint()
    elif cmd == "add-user":
        user=getArg(args, 1, "username")
        password = getpass("Enter password:")
        password_repeat = getpass("And again:")
        if password != password_repeat:
            _printErrorAndExit("Passwords don't match")
        ProcessedResponse(clnt.addUser(user, password)).pprint()
    elif cmd == "delete-user":
        user=getArg(args, 1, "username")
        ProcessedResponse(clnt.deleteUser(user)).pprint()
    elif cmd == "promote-user":
        user=getArg(args, 1, "username")
        ProcessedResponse(clnt.promoteUser(user)).pprint()
    elif cmd == "demote-user":
        user=getArg(args, 1, "username")
        ProcessedResponse(clnt.demoteUser(user)).pprint()
    elif cmd == "grant-access":
        user=getArg(args, 1, "username")
        ProcessedResponse(clnt.grantAccess(user)).pprint()
    elif cmd == "users":
        renderMethod = CmdLine.listUsers
        resp = clnt.listRequest("users")
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "version":
        cmd_line_utils.printLogo()
        cmd_line_utils.printAuthors()
        print("Client version:  %s"%__version__)
        print("\nConnecting to server for version information:")
        ProcessedResponse(clnt.serverInfo()).pprint(CmdLine.serverInfo)
    elif cmd == "queue" or cmd=="q":
        resp = clnt.listRequest("queue")
        renderMethod = CmdLine.listQueue
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "running" or cmd == "r":
        resp = clnt.listRequest("running")
        renderMethod = CmdLine.listRunning
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "heartbeats" or cmd == "h":
        resp = clnt.listRequest("heartbeats")
        renderMethod = CmdLine.listHeartbeats
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "command-failed":
        id=getArg(args, 1, "command ID")
        #server=None
        ProcessedResponse(clnt.commandFailedRequest(id,0)).pprint()
    # dataflow application specific messages 
    elif cmd == "start": 
        name=getArg(args, 1, "project name")
        ProcessedResponse(clnt.projectStartRequest(name)).pprint()
    elif cmd == "remove" or cmd == "rm":
        delDir=True
        name=None
        for arg in args:
            if arg == cmd:
                continue
            if arg == "-k":
                delDir=False
            else:
                name=arg
        if name is None:
            _printErrorAndExit("Missing project name for project-delete")
        ProcessedResponse(clnt.projectDeleteRequest(name, delDir)).pprint()
    elif cmd == "projects" or cmd == "p":
        renderMethod = CmdLine.listProjects
        ProcessedResponse(clnt.projectsRequest()).pprint(renderMethod)
    elif cmd == "set-default" or cmd == "cd":
        project=getArg(args, 1, "project name")
        ProcessedResponse(clnt.projectSetDefaultRequest(project)).pprint()
    elif cmd == "get-default" or cmd == "pwd":
        ProcessedResponse(clnt.projectGetDefaultRequest()).pprint()
    elif cmd == "list" or cmd == "ls":
        project, pargs = getProjectArgs(args)
        if len(pargs) > 1:
            item=getArg(pargs, 1, "project item to list")
        else:
            item=""
        resp = clnt.projectListRequest(project, item)
        renderMethod = CmdLine.listActiveItems
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "info":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "item to get info for")
        resp = clnt.projectInfoRequest(project, item)
        renderMethod = CmdLine.writeInfo
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "debug":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "item to get debug info for")
        resp = clnt.projectDebugRequest(project, item)
        ProcessedResponse(resp).pprint(None)
    elif cmd == "graph": 
        project, pargs = getProjectArgs(args)
        if len(pargs) > 1:
            item=getArg(pargs, 1, "project item to make graph of")
        else:
            item=""
        resp = clnt.projectGraphRequest(project, item)
        renderMethod = CmdLine.makeDotGraph
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "log":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "instance to get log for")
        isFile = True
        response = clnt.projectLogRequest(project, item)
        if response.content_type=="text/json":
            ProcessedResponse(response).pprint()
        else:
            filecontents = response.getRawData() #this is an mmap
            sys.stdout.write(filecontents.read(len(filecontents)))
    elif cmd == "activate":
        project, pargs = getProjectArgs(args)
        if len(pargs) > 1:
            item=getArg(pargs, 1, "project item to list")
        else:
            item=""
        ProcessedResponse(clnt.projectActivateRequest(project, item)).pprint()
    elif cmd == "deactivate" or cmd == "hold":
        project, pargs = getProjectArgs(args)
        if len(pargs) > 1:
            item=getArg(pargs, 1, "project item to list")
        else:
            item=""
        ProcessedResponse(clnt.projectHoldRequest(project, item)).pprint()
    elif cmd == "clear-error":
        project, pargs = getProjectArgs(args)
        if len(pargs) > 1:
            item=getArg(pargs, 1, "project item to list")
        else:
            item=""
        ProcessedResponse(clnt.projectRerunRequest(project, 
                                                   item, 
                                                   True)).pprint()
    elif cmd == "force-rerun":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "project item to list")
        ProcessedResponse(clnt.projectRerunRequest(project, 
                                                   item, 
                                                   False)).pprint()
    elif cmd == "upload":
        project, pargs = getProjectArgs(args)
        filename=getArg(pargs, 1, "project XML file")
        ProcessedResponse(clnt.projectUploadRequest(project, filename)).pprint()
    elif cmd == "get":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "name of input/output item to get")
        resp = clnt.projectGetRequest(project, item)
        renderMethod = CmdLine.getItem
        ProcessedResponse(resp).pprint(renderMethod)
        #ProcessedResponse(clnt.projectGetRequest(project, item)).pprint()
    elif cmd == "get-file" or cmd == "getf":
        project, pargs = getProjectArgs(args)
        if len(pargs)<2:
            print("Missing argument: item name") 
            sys.exit(1)
        if pargs[1] == "-f":
            if len(pargs)<3:
                print("Missing argument: file name") 
            if len(pargs)<4:
                print("Missing argument: item name") 
            output=pargs[2]
            item=pargs[3]
        else:
            output=None
            item=pargs[1]
        #item=getArg(pargs, 1, "name of input/output item to get")
        #output=getArg(pargs, 2, "what we want to save the file as")
        isFile = True
        response = clnt.projectGetRequest(project, item,isFile)
        if response.content_type=="text/json":
            ProcessedResponse(response).pprint()
        else:
            filecontents = response.getRawData() #this is an mmap
            if output is not None:
                file = open(output,"wb") 
            else:
                file = sys.stdout
            file.write(filecontents.read(len(filecontents)))
            if output is not None:
                file.close()
                print "item %s saved in %s"%(item,output)
    elif cmd == "set":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "name of input item to set")
        value=getArg(pargs, 2, "value of input item to set")
        ProcessedResponse(clnt.projectSetRequest(project, item, value,
                                                 None)).pprint()
    elif cmd == "set-file" or cmd == "setf":
        project, pargs = getProjectArgs(args)
        item=getArg(pargs, 1, "name of input item to set")
        filename=getArg(pargs, 2, "input file to set")
        ProcessedResponse(clnt.projectSetRequest(project, item, None,
                                                 filename)).pprint()
    elif cmd == "transact":
        project, pargs = getProjectArgs(args)
        ProcessedResponse(clnt.projectTransactRequest(project)).pprint()
    elif cmd == "commit":
        project, pargs = getProjectArgs(args)
        ProcessedResponse(clnt.projectCommitRequest(project)).pprint()
    elif cmd == "rollback":
        project, pargs = getProjectArgs(args)
        ProcessedResponse(clnt.projectRollbackRequest(project)).pprint()
    elif cmd == "list-modules":
        resp = clnt.listRequest("modules")
        renderMethod = CmdLine.listModules
        ProcessedResponse(resp).pprint(renderMethod)
    elif cmd == "import":
        project, pargs = getProjectArgs(args)
        module=getArg(pargs, 1, "name of module to import")
        ProcessedResponse(clnt.projectImportRequest(project, 
                                                    module)).pprint()        
    elif cmd == "instance":
        project, pargs = getProjectArgs(args)
        fn=getArg(pargs, 1, "function name of new instance")
        name=getArg(pargs, 2, "name of new instance")
        ProcessedResponse(clnt.projectAddInstanceRequest(project, fn, 
                                                         name)).pprint()
    elif cmd == "connect":
        project, pargs = getProjectArgs(args)
        src=getArg(pargs, 1, "connection source")
        dst=getArg(pargs, 2, "connection destination")
        ProcessedResponse(clnt.projectConnectRequest(project, 
                                                     src, dst)).pprint()
    elif cmd == "trust":
        if ("-all" in args):
            ProcessedResponse(clnt.grantAllNodeConnections()).\
            pprint(CmdLine.grantNodeConnectRequests)
        else:
            serverId = getArg(args,1, "server-id")
            ProcessedResponse(clnt.grantNodeConnection(serverId)).pprint(CmdLine.grantNodeConnectRequests)

    elif cmd == "connect-server":
        host = getArg(args,1,"hostname")
        client_secure_port = None
        server_secure_port = None
        if len(args)>2:
            client_secure_port = str(getArg(args,2,'client_secure_port'))
        else:
            client_secure_port = Conf.getDefaultClientSecurePort()
                  
        ProcessedResponse(clnt.addNode(host, client_secure_port)).\
        pprint(CmdLine.addNodeRequest)

    elif cmd == 'connected-servers' or cmd=='cs':
        ProcessedResponse(clnt.listServers()).pprint(CmdLine.listServers)
    
    elif cmd == "revoke":
        print "WARNING: The revoke command has security issues and a revoked"
        print "server is not to be considered revoked from a security perspective"
        print "---"
        serverId = getArg(args,1,"server Id")
        ProcessedResponse(clnt.revokeNode(serverId)).pprint()

    elif cmd == "change-node-priority" or cmd == "set-pri":
        if len(args) >= 3:
            priority = getArg(args,1,"priority")
            host = getArg(args,2,"host")
            port = 13807
        
        if len(args)>3:
            port = getArg(3,"port")
        ProcessedResponse(clnt.changeNodePriority(host,priority,port)).\
                  pprint(CmdLine.listNodes)
            
    elif cmd == "network":
        ProcessedResponse(clnt.networkTopology()).\
                  pprint(CmdLine.networkTopology)
        
    elif cmd == "network-graph":  #calls graphviz
        
        filename = getArg(args,1,'filename')
        file = open(filename,"w")
        processedResponse = ProcessedResponse(clnt.networkTopology())
        file.write(CmdLine.networkTopology(processedResponse.resp[0]))
        file.close() 
        subprocess.call(["dot","-Tsvg",filename,'-o',filename+".svg"])

    elif cmd == "status" or cmd == "s":
        project = None
        if len(args) > 1:
            project = getArg(args,1,"project")
        ProcessedResponse(clnt.statusRequest(project)).pprint(CmdLine.status)

    elif cmd == "readconf":
        ProcessedResponse(clnt.readConfRequest()).pprint()
    
    elif cmd == "stop-server":
        ProcessedResponse(clnt.stopRequest()).pprint()

    elif cmd == "server-info":
        ProcessedResponse(clnt.serverInfo()).pprint(CmdLine.serverInfo)

    elif cmd == "ping":
        serverId = None  #will ping the server the client is connected to

        if(len(args)>1):
            serverId = getArg(args,1,"serverId")

        ProcessedResponse(clnt.pingServer(serverId)).pprint()


    elif cmd == "save-state":
        ProcessedResponse(clnt.saveStateRequest()).pprint()


    # save and load project commands
    elif cmd =="save":

        project= getArg(args,1,"Project name")

        savePath = "%s.tar.gz"%project
        if(len(args)>2):
            savePath=getArg(args, 2, "Destination file")

        response = clnt.projectSaveRequest(project)

        if response.content_type=="text/json":
            ProcessedResponse(response).pprint()

        else:
            filecontents = response.getRawData() #this is an mmap
            #try catch here!! test if file can be written in destination
            try:
                file=open(savePath,"wb")
                file.write(filecontents.read(len(filecontents)))
                file.close()
            except IOError as e:
                _printErrorAndExit("Could not save project to %s\nError %s"%(
                    savePath, e.strerror))


            print "Saved project to %s"%savePath
    elif cmd =="load":
        #provided a project file it will restore it on the server side

        #path to the file
        projectFile = getArg(args, 1, "Path to project file")  
        projectName = getArg(args, 2, "Name of project")  

        ProcessedResponse(clnt.projectRestoreRequest(projectFile,
                                                     projectName)).pprint()
    else: 
        _printErrorAndExit("ERROR: unknown command '%s'"%cmd)

except ResponseError as e:
    _printErrorAndExit("Request failed:\n%s\n"%str(e))
except (ClientError, cpc.util.CpcError) as e:
    _printErrorAndExit("ERROR: %s"%str(e))