#!/usr/bin/python
# sim-info -- information about simfactory
#
# Michael Thomas <mthomas@cct.lsu.edu>
# Center for Computation & Technology
# Louisiana State University 
#

import sys, os, shutil, time

############################################
## APP SPECIFIC DEFINES ##
#
# Usage			   when (-h, --help) is used, this is the first line showing how to call the app
# optionGroups	  which option groups from etc/options to import. common is always imported. 

App = "sim-info"
Usage = "usage: %prog command"
optionGroups = ['sim-info']
Purpose = "display some convienient information about simfactory"

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

############################################
## INIT ##

if os.path.basename(sys.argv[0]) == App:
	rp = os.path.abspath(__file__)
	
	paths = rp.split(os.sep)

	paths.pop()
	paths.pop()
	
	global BASE_PATH
	BASE_PATH = os.sep.join(paths)
	sys.path.append(BASE_PATH)
	
	LIB_PATH = "%s%slib" % (BASE_PATH, os.sep)
	
	sys.path.append(LIB_PATH)
	
from lib import *

import libutil
import simarchive

from libutil import dprint

global known_commands
global known_help
known_commands = ['list-machines', 'print-mdb-entry', 'whoami', 'print-mdb', 'list-archived-simulations',
'list-configurations', 'list-simulations']
usage_strings = {'list-machines':'list all the machines in the machine database',
		'print-mdb-entry':'list information about a single machine',
		'whoami':'what is the name of the machine simfactory is running on',
		'print-mdb':'print parsable mdb',
		'list-configurations':'list simfactory cactus configurations',
		'list-simulations':'list simfactory cactus simulations',
		'list-archived-simulations': 'list archived simulations'}
		
def buildUsageString():
	global Usage
	global known_commands
	global usage_strings
	
	cmdString = "%s\n\n\nAvailable Commands:\n" % Usage
	iString = []
	
	for kk in known_commands:
		ss = "  %-35s%s" % (kk, usage_strings[kk])
		iString.append(ss)
	
	cmdString = "%s%s" % (cmdString, "\n".join(iString))
	return cmdString

############################### INFO FUNCTIONS ###############################


	
def list_archived_simulations():
	global SimLib
	global SimEnvironment
	
	SimEnvironment.RequireMachine()
	
	machineEntry = SimEnvironment.LocalMachineEntry
		
	SimLib.VerifyKeys(machineEntry, ['archivetype'])
		
	archiveType = machineEntry.archivetype
	
	ArchiveEngine = simarchive.SimArchive(SimEnvironment, archiveType)
	ArchiveEngine.authenticate()
	
	simulations = ArchiveEngine.listSimulations()
	
	for sim in simulations:
		dprint("\n%s: " % sim['SimulationId'])
		dprint("        Archive Path: %s" % sim['StoredPath'])
		dprint("     Simulation Name: %s" % sim['SimulationName'])
		dprint("             Machine: %s" % sim['Machine'])
		dprint("            Hostname: %s" % sim['Hostname'])
		dprint("                User: %s" % sim['User'])
		dprint("                Date: %s" % sim['Date'])
		
		restarts = sim['Restarts']
		
		dprint("            Restarts: found %s restart(s)" % len(restarts))
		
		for r in restarts:
			dprint("                      %s" % r)
		
	
def list_simulations():
	global SimLib
	global SimEnvironment

	
	SimEnvironment.RequireMachine()
	
	simulations = SimLib.GetSimulations()
	
	if len(simulations) == 0:
		dprint("There are no simulations")
		return
	
	dprint("Simulations:")
	for sim in simulations:
		restart = simrestart.SimRestart(SimEnvironment)
		restart.load(sim)
		
		restartIds = SimEnvironment.RestartLib.GetRestartIds(restart)
		activeId = SimEnvironment.RestartLib.GetActiveRestartId(restart)
		
		if len(restartIds) == 0:
			dprint("   %-21s   [no restarts found, skipping]\n" % sim)
			continue
		
		if activeId == 0:
			activeId = restartIds[len(restartIds)-1]
		
		ret = restart.loadFromRestartId(activeId)
		
		if ret < 0:
			dprint("Error reading simulation %s with restart %s, broken/old simulation, skipping" % (sim, activeId))
			continue
		
		state = None
		if restart.Properties.queued == 'yes':
			state = 'QUEUED'
		elif restart.Properties.running == 'yes':
			state = "ACTIVE"		
		else:
			state = "FINISHED"
		
		job_id = restart.GetJobId()
		
		
		verbose = OptionsManager.GetOption('verbose')
		
		if verbose == False:
			dprint("   %-21s   [%s,   restart id \"%04d\", job id \"%s\"]" % (sim, state, int(activeId), job_id))
		else:
			dprint("   %-21s= %s" % (sim, state))
			
			size_in_k = int(os.popen("du -sk %s | cut -f1" % restart.SimulationDir).read().strip())
			size_in_bytes = size_in_k * 1024
			size_in_gb = size_in_bytes / 1.0e+9

			# Active Restart Id
			str = libutil.BuildWithSpace("restart id", 16)
			libutil.PrintManyLeadingSpace("%s= \"%04d\"" % (str, int(activeId)), 4)

			# Job
			str = libutil.BuildWithSpace("job id", 16)
			libutil.PrintManyLeadingSpace("%s= \"%s\"" % (str, job_id), 4)
			
			# Disk Usage
			str = libutil.BuildWithSpace("Disk usage", 16)
			libutil.PrintManyLeadingSpace("%s= %02f Gbytes" % (str, size_in_gb), 4)

			# current iteration (if running)
			
			if state == 'RUNNING':
				pass
			
			# Properties
			libutil.PrintManyLeadingSpace(restart.Properties.toString(), 4)

	
def list_machines():
	global ConfigurationDatabase
	
	machines = ConfigurationDatabase.GetMachines()
	
	for machine in machines:
		entry = ConfigurationDatabase.GetMachine(machine)
		dprint("   %-12s   %6d nodes,  %4d ppn   %-30s   %s" % (machine, int(entry.nodes), int(entry.ppn), entry.hostname, entry.status))

def print_mdb_entry():
	global ConfigurationDatabase
	global OptionsManager
	
	if len(OptionsManager.args) == 0:
		dprint("Error: no machine specified")
		sys.exit(1)
		
	for i in range(len(OptionsManager.args)):
		machineName = OptionsManager.args[i]
		ConfigurationDatabase.MachineParser.PrintSection(machineName)
		
def whoami():
	global SimLib
	machine = SimLib.GetMachineName()
	dprint("Current machine: %s" % machine)

def print_mdb():
	global ConfigurationDatabase

	if len(OptionsManager.args) == 0:
		ConfigurationDatabase.MachineParser.PrintIni()
		return
	else:
		print_mdb_entry()
		return
		
def RemoteExecute(machineName):
	global SimEnvironment
	
	RemoteEnvironment = simremote.RemoteEnvironment(SimEnvironment)
	RemoteEnvironment.init(machineName)
	RemoteEnvironment.ExecuteSameCommand(parrotArguments=True, stripArguments=['remotemachine'])
	
def list_configurations():
	global SimLib
	global SimEnvironment
	#dprint("list_configurations")
	
	SimEnvironment.RequireMachine()
	
	configs = SimLib.GetConfigurations()
	
	if len(configs) == 0:
		dprint("There are no configurations")
		return
	
	dprint("Configurations:")
	
	for config in configs:
		dprint("   %-40s" % config,)
		configBase = SimLib.BuildPath([SimEnvironment.CONFIGS_PATH, config])
		exe = SimLib.BuildPath([SimEnvironment.APP_PATH, 'exe', 'cactus_%s' % config])
		if not(os.path.exists(exe)):
			dprint("   [incomplete]")
		else:
			statinfo = os.stat(exe)
			tinfo = time.localtime(statinfo.st_mtime)
			
			date = "%s-%02d-%02d %2d:%02d:%02d" % (tinfo.tm_year,tinfo.tm_mon,tinfo.tm_mday, tinfo.tm_hour,tinfo.tm_min,tinfo.tm_sec)
			dprint("   [built %s]" % date)
############################### MAIN ###############################

def main(env):
	global OptionsManager
	global ConfigurationDatabase
	global SimLib
	global DefineDatabase
	global SimEnvironment
	global known_commands
	
	SimEnvironment = env
	
	OptionsManager = SimEnvironment.OptionsManager
	ConfigurationDatabase = SimEnvironment.ConfigurationDatabase
	SimLib = SimEnvironment.SimLib
	DefineDatabase = SimEnvironment.DefineDatabase
	
	############################################
	
	## HEADER ##
	
	if os.path.basename(SimEnvironment.EXECUTABLE) == App:
		dprint("sim-info: %s" % Purpose, True)
		
		dprint("defs: %s" % SimEnvironment.cdb)
		
		if SimEnvironment.udb != None:
			dprint("defs.local: %s" % SimEnvironment.udb)

		print
	
	
	if len(OptionsManager.args) == 0 and SimEnvironment.COMMAND == None:
		OptionsManager.PrintHelp()
		sys.exit(0)
	
	if OptionsManager.HasOption("remotemachine"):
		remoteMachine = OptionsManager.GetOption("remotemachine")
		dprint("Managing for remote machine: %s" % remoteMachine, True)
		RemoteExecute(remoteMachine)
		return
	
	cactusDir = SimEnvironment.APP_PATH
	
	if SimEnvironment.VERBOSE:
		dprint("Cactus Directory: %s" % cactusDir)
	
	if os.getcwd() != cactusDir:
		if SimEnvironment.VERBOSE:
			dprint("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)
	
	if SimEnvironment.COMMAND != None:
		command = SimEnvironment.COMMAND
	else:
		command = OptionsManager.args[0]
	
	if command not in known_commands:
		dprint("Error, unknown sim-info command %s" % command, True)
		sys.exit(1)
	
	# - not a valid function character
	command = command.replace("-", "_")
	
	SimEnvironment.RestartLib.CleanupRestarts()
	
	SimEnvironment.ForceVerbose()
	
	# execute the reqisite function.
	globals()[command]()
	
	SimEnvironment.ResetVerbose()

# only run if you are App
if os.path.basename(sys.argv[0]) == App:
	global SimEnvironment
	SimEnvironment = simenv.SimEnvironment(BASE_PATH, os.path.abspath(sys.argv[0]))
	SimEnvironment.initApp(usageString=buildUsageString(), optionGroups=optionGroups)
	main(SimEnvironment)