# sim-manage -- manage simulations.
#
# Michael Thomas <mthomas@cct.lsu.edu>
# Center for Computation & Technology
# Louisiana State University 
#

import sys, os, time

optionGroups = ['sim-manage']
Purpose = "manage a Cactus process"

############################################

from libutil import *
import simenv,simlib,restartlib,simrestart

## lets go to work

known_commands = ['create', 'submit', 'run', 'interactive', 'stop', 'archive', 'cleanup', 'get-output-dir',
                'show-output', 'create-submit', 'create-run', 'purge', 'run-debug']
usage_strings = {
                'create': 'create a simulation', 
                'submit': 'submit a simulation', 
                'cleanup': 'clean up a simulation',
                'create-submit': 'create and submit a simulation',
                'create-run': 'create and run a simulation',
                'run': 'launch a simulation', 
                'interactive': 'initiate an interactive session on a compute node',
                'stop': 'stop an active simulation',
                'show-output': 'show the output of a simulation',
                'archive': 'archive a simulation or an individual restart',
                'run-debug': 'launch simulation using an interactive debugger',
                'get-output-dir': 'get the output directory for a given simulation/restart',
                'purge': 'purge a simulation'}

############################### MAIN ###############################

def command_purge():
    if len(simenv.OptionsManager.args) == 0:
        fatal("Error: no simulation name specified\nUsage: %s purge <simulationname> <simulationname> ..." % sys.argv[0])
        
    for simulationName in simenv.OptionsManager.args:
        simulationName = simenv.OptionsManager.args.pop(0)
    
        display("Simulation name: %s" % simulationName)
        
        restart = simrestart.SimRestart()
        
        ret = restart.load(simulationName)
        
        if ret == -1:
            fatal("unable to load simulation %s for purging" % simulationName)

        restart.trash()
        
        restart.done()

def command_cleanup():

    simulations = simenv.OptionsManager.args
    
    if len(simulations) == 0:
        info("Cleaning up all simulations")
        simulations = simlib.GetSimulations()

    for simulationName in simulations:

        info("Simulation name: %s" % simulationName)
        
        restartlib.CleanupSimulation(simulationName, quiet=False, ignoreTimestamps=True)


def command_interactive():
    restart = simrestart.SimRestart()
    restart.interactive()
        
def command_create():
    if simenv.CACTUS_PATH == None:
        fatal("cannot proceed with unknown CACTUS_PATH")
    
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        if len(simenv.OptionsManager.args) == 0:
            fatal("no simulation name specified")
            
        simulationName = simenv.OptionsManager.args.pop(0)
        display("Simulation name: %s" % simulationName)

    parfile = simlib.GetParFile()
    
    if parfile == None:
        fatal("no parameter file specified")
    
    display("Parameter file: %s" % parfile)
    
    restart = simrestart.SimRestart()
    restart.create(simulationName, parfile)
    restart.done()

def command_create_submit():
    
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        simulationName = simenv.OptionsManager.args.pop(0)
        display("Simulation name: %s" % simulationName)
    else:
        simenv.OptionsManager.args.insert(0, simulationName)
        
    command_create()
    
    #reinsert our simulationname since command_create popped it off.
    simenv.OptionsManager.args.insert(0, simulationName)
    
    command_submit()

def command_create_run():
    
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        simulationName = simenv.OptionsManager.args[0]
        display("Simulation name: %s" % simulationName)
    else:
        simenv.OptionsManager.args.insert(0, simulationName)
        
    command_create()
    
    #reinsert our simulationname since command_create popped it off.
    simenv.OptionsManager.args.insert(0, simulationName)
    
    command_run()
    
def command_run():
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        simulationName = simenv.OptionsManager.args.pop(0)
    
    display("Simulation name: %s" % simulationName)
    
    restart = simrestart.SimRestart()
    ret = restart.load(simulationName)
    
    if ret == -1:
        fatal("unable to load simulation %s for execution" % simulationName)
    
    if simenv.OptionsManager.HasOption('restart-id'):
        restart_id = simenv.OptionsManager.GetOption('restart-id')
        restart.submitRun(simulationName, restart_id)
    else:
        restart.userRun(simulationName)
        restart.done()
    
def command_run_debug():
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        simulationName = simenv.OptionsManager.args.pop(0)
    
    display("Simulation name: %s" % simulationName)
    
    restart = simrestart.SimRestart()
    
    ret = restart.load(simulationName)
    
    if ret == -1:
        fatal("unable to load simulation %s for execution" % simulationName)
                
    restart.userRun(simulationName, debug=True)
    restart.done()
    
def command_submit():
    simulationName = simlib.ParseSimulationCommandLine()
    
    if simulationName == None:
        
        if len(simenv.OptionsManager.args) == 0:
            fatal("No simulation name specified")
            
        simulationName = simenv.OptionsManager.args.pop(0)
        display("Simulation name: %s" % simulationName)
    
    restart = simrestart.SimRestart()
    restart.userSubmit(simulationName)
    restart.done()
    

def command_get_output_dir():

    simulationName = None

    if simulationName == None:
        simulationName = simenv.OptionsManager.args.pop(0)
        display("Simulation name: %s" % simulationName)

    restart = simrestart.SimRestart()

    restart_id = -1

    if simenv.OptionsManager.HasOption('restart-id'):
        restart_id = simenv.OptionsManager.GetOption('restart-id')
    else:
        restart_id = restartlib.GetMaxRestartID(simulationName)

    restart.load(simulationName, restart_id)

    parfile = restart.Properties.parfile
    pf = simlib.FileBaseName(parfile)
    output_dir = simlib.BuildPath(restart.RestartDir, pf)

    display("Output directory: %s" % output_dir)
    
    restart.done()

def command_show_output():
    simulationName = simenv.OptionsManager.args.pop(0)
    
    display("Simulation name: %s" % simulationName)
    
    restart_id = -1

    if simenv.OptionsManager.HasOption('restart-id'):
        restart_id = simenv.OptionsManager.GetOption('restart-id')
    else:
        restart_id = restartlib.GetMaxRestartID(simulationName)
        
    restart = simrestart.SimRestart()
    ret = restart.load(simulationName, restart_id)
    
    if ret == -1:
        fatal("unable to load simulation %s for output" % simulationName)
        
    restart.show_output()
    
    restart.done()
    
def command_stop():
    
    for simulationName in simenv.OptionsManager.args:
        simulationName = simenv.OptionsManager.args.pop(0)
        
        display("Simulation name: %s" % simulationName)
    
        if simenv.OptionsManager.HasOption('restart-id'):
            restart_id = simenv.OptionsManager.GetOption('restart-id')
            restart = restartlib.GetRestartByRestartId(simulationName, restart_id)
            restart.stop()
            restart.done()
            return
    
        if simenv.OptionsManager.HasOption('job-id'):
            job_id = simenv.OptionsManager.GetOption('job-id')
            info("Have job_id: %s" % job_id)
            restart = restartlib.GetRestartByJobId(simulationName, job_id)
            restart.stop()
        
            # stop does not call finish automatically, because finish() may call stop().
            restart.finish()
            restart.done()
            return
    
        restartlib.StopAllActiveRestarts(simulationName)

def command_archive():
    simulationName = simenv.OptionsManager.args.pop(0)
    
    display("Simulation name: %s" % simulationName)
    
    if simenv.OptionsManager.HasOption('restart-id'):
        restart_id = simenv.OptionsManager.GetOption('restart-id')
        restart = restartlib.GetRestartByRestartId(simulationName, restart_id)
    else:
        restart = simrestart.SimRestart()
        ret = restart.load(simulationName)
    
        if ret < 0:
            fatal("unable to load simulation %s for archiving" % simulationName)
    
    restart.archive()
    restart.done()
    
def CommandDispatch():
    global known_commands
    
    if simenv.COMMAND == None:
        command = simenv.OptionsManager.args.pop(0)
    else:
        command = simenv.COMMAND
    
    if command not in known_commands:
        display("Error: unknown command %s" % command)
        simenv.OptionsManager.PrintHelp()
        sys.exit(0)
    
    command = command.replace("-", "_")
    
    info("Executing command: %s" % command)
    exec("command_%s()" % command)

def main():

    simlib.RequireMachine()
    
    # require all capabilities for these commands.
    simenv.ConfigurationDatabase.RequireCapability("simulation", "access", "source")

    cactusDir = simenv.CACTUS_PATH
    info("Cactus Directory: %s" % cactusDir)
    
    if os.getcwd() != cactusDir:
        warning("Current Working directory does not match Cactus sourcetree, changing to %s" % cactusDir)
        # make sure we're in the Cactus source directory, otherwise all of this will blow way up.
        # os.chdir(cactusDir)
    
    ############################################

    info("simenv.COMMAND: %s" % simenv.COMMAND)
    if len(simenv.OptionsManager.args) < 2 and simenv.COMMAND == None:
        simenv.OptionsManager.PrintHelp()
        sys.exit(0)

    CommandDispatch()