source: branches/numpy_anuga_validation/automated_validation_tests/patong_beach_validation/validate_patong.py @ 6828

'''
Automatic verification that the ANUGA code runs the Patong simulation
and produces the expected output.

Required files are downloaded from the ANUGA servers if they are
out of date or missing.
'''

import sys
import os
import glob
import unittest
import time
import shutil

from anuga.utilities.system_tools import get_web_file, untar_file
import anuga.utilities.log as log


# base URL for the remote ANUGA data
PATONG_HOST = 'http://10.7.64.243/'
PATONG_DATA_URL = PATONG_HOST + 'patong_validation_data/'

# path to the local data directory
Local_Data_Directory = os.path.join('.', 'local_data')

# path to the remote data directory
Remote_Data_Directory = os.path.join('.', 'remote_data')

# sequence of required local data objects
# first is always the SWW file to be compared
Local_Data_Objects = ('patong.sww', 'data')

# name of stdout catch file for runmodel.py
RUNMODEL_STDOUT = 'runmodel.stdout'

# text at start of 'output dir' line in RUNMODEL_STDOUT file
OUTDIR_PREFIX = 'Make directory '

# Name of SWW file produced by simulationvalidate_patong.py
OUTPUT_SWW = 'patong.sww'


def setup():
    '''Prepare for the validation run.

    Check we have required data set in project.py.
    '''
   
    pass


def update_local_data():
    '''Update local data objects from the server.

    These are expected to be *.tgz files/directories.
    Return True if all went well, else False.
    '''
    
    # local function to update one data object
    def update_object(obj, auth):
        '''Update object 'obj' using authentication tuple 'auth'.
        
        Return updated auth object (success) or False (failure).
        '''

        log.info("Refreshing local object '%s'" % obj)

        # Get a unique date+time string to defeat caching.  The idea is to add
        # this to the end of any URL so proxy sees a different request.
        cache_defeat = '?' + time.strftime('%Y%m%d%H%M%S')

        # create local and remote paths, URLs, etc.
        remote_path = os.path.join(Remote_Data_Directory, obj)
        remote_digest = remote_path + '.tgz.digest'
        
        local_path = os.path.join(Local_Data_Directory, obj)
        local_file = local_path + '.tgz'
        local_digest = local_file + '.digest'
        
        object_url = PATONG_DATA_URL + obj + '.tgz'
        digest_url = object_url + '.digest'

        # see if missing either digest or object .tgz
        if not os.path.exists(local_digest) or not os.path.exists(local_file):
            # no digest or no object, download both digest and object
            log.info('Fetching remote file %s' % digest_url)
            auth = get_web_file(digest_url+cache_defeat,
                                local_digest, auth=auth)
            if auth == False:
                log.info("Couldn't fetch file: %s" % digest_url)
                return False
            log.info('Fetching remote file %s' % object_url)
            auth = get_web_file(object_url+cache_defeat, local_file, auth=auth)
            if auth == False:
                return False
        else:
            # download object digest to remote data directory
            log.info('Fetching remote file %s' % digest_url)
            auth = get_web_file(digest_url+cache_defeat,
                                remote_digest, auth=auth)
            if auth == False:
                return False
            
            # compare remote with local digest
            fd = open(local_digest, 'r')
            local_data_digest = fd.read()
            fd.close()

            fd = open(remote_digest, 'r')
            remote_data_digest = fd.read()
            fd.close()

            # if digests differ, refresh object
            if local_data_digest != remote_data_digest:
                log.info('Local file %s is out of date' % obj)
                fd = open(local_digest, 'w')
                fd.write(remote_data_digest)
                fd.close()

                log.info('Fetching remote file %s' % object_url)
                auth = get_web_file(object_url+cache_defeat,
                                    local_file, auth=auth)
        return auth

    # create local data directory if required
    log.debug('Creating local directory: %s' % Local_Data_Directory)
    if not os.path.exists(Local_Data_Directory):
        os.mkdir(Local_Data_Directory)

    # clean out remote data copy directory
    log.debug('Cleaning remote directory: %s' % Remote_Data_Directory)
    shutil.rmtree(Remote_Data_Directory, ignore_errors=True)
    os.mkdir(Remote_Data_Directory)

    # refresh local files
    auth = None
    for data_object in Local_Data_Objects:
        log.debug('Trying to update: %s' % data_object)
        auth = update_object(data_object, auth)
        if auth == False:
            log.debug('Failed fetching %s, returning False' % data_object)
            return False

    # unpack *.tgz files
    for data_object in Local_Data_Objects:
        tar_path = os.path.join(Local_Data_Directory, data_object+'.tgz')
        log.info('Untarring %s in directory %s ...'
                 % (tar_path, Local_Data_Directory))
        untar_file(tar_path, target_dir=Local_Data_Directory)
        
    log.info('Local data has been refreshed.')
    return True


def can_we_run():
    '''Decide if we can run with the files we have.
    
    Return True if we *can* run, else False.

    Tell user what is happening first, then untar files.
    '''

    log.critical('Checking if you have the required files to run locally ...')

    have_files = True
    max_width = 0
    for obj in Local_Data_Objects:
        max_width = max(len(obj), max_width)

    for obj in Local_Data_Objects:
        # if we don't have required object, can't run
        obj_path = os.path.join(Local_Data_Directory, obj+'.tgz')
        if os.path.exists(obj_path):
            log.info('%s  found' % obj.ljust(max_width))
        else:
            log.info('%s  MISSING!' % obj.ljust(max_width))
            have_files = False

    if not have_files:
        log.critical('You must obtain the missing files before you can run '
                     'this validation.')
        return False

    log.critical('You have the required files.')

    # now untar file/directory objects
    for data_object in Local_Data_Objects:
        tar_path = os.path.join(Local_Data_Directory, data_object+'.tgz')
        log.info('Untarring %s in directory %s ...'
                 % (tar_path, Local_Data_Directory))
        untar_file(tar_path, target_dir=Local_Data_Directory)

    return True


def run_simulation():
    '''Run the Patong simulation.'''
    
    # modify environment so we use the local data
    new_inundationhome = os.path.join(Local_Data_Directory, '')
    os.environ['INUNDATIONHOME'] = new_inundationhome
    new_muxhome = os.path.join(Local_Data_Directory, 'data')
    os.environ['MUXHOME'] = new_muxhome

    # We import here, _after_ environment variables are set
    import project

    # run the simulation, produce SWW file
    log.critical('Running Patong simulation ...')
    cmd = 'python run_model.py > %s' % RUNMODEL_STDOUT
    res = os.system(cmd)
    assert res == 0

def check_that_output_is_as_expected():
    '''Check that validation output is as required.'''

    # get path to expected SWW file
    log.critical('Checking that simulation results are as expected ...')
    local_sww = os.path.join(Local_Data_Directory, Local_Data_Objects[0])

    # get output directory from stdout capture file
    try:
        fd = open(RUNMODEL_STDOUT, 'r')
    except IOError, e:
        log.critical("Can't open catch file '%s': %s"
                     % (RUNMODEL_STDOUT, str(e)))
        return 1
    lines = fd.readlines()
    fd.close

    output_directory = None
    for line in lines:
        if line.startswith(OUTDIR_PREFIX):
            output_directory = line.replace(OUTDIR_PREFIX, '', 1)
            output_directory = output_directory.strip('\n')
            break
    if output_directory is None:
        log.critical("Couldn't find line starting with '%s' in file '%s'"
                     % (OUTDIR_PREFIX, RUNMODEL_STDOUT))
        return 1

    # compare SWW files here and there
    new_output_sww = os.path.join(output_directory, OUTPUT_SWW)
    cmd = 'python cmpsww.py %s %s > cmpsww.stdout' % (local_sww, new_output_sww)
    res = os.system(cmd)
    if res == 0:
        log.info('Simulation results are as expected.')
    else:
        log.critical('Simulation results are NOT as expected.')
        fd = open('cmpsww.stdout', 'r')
        cmp_error = fd.readlines()
        fd.close()
        log.critical('\n' + ''.join(cmp_error))


def teardown():
    '''Clean up after validation run.'''
    
    # clear all data objects from local data directory
    for data_object in Local_Data_Objects:
        obj_path = os.path.join(Local_Data_Directory, data_object)
        if os.path.isfile(obj_path):
            os.remove(obj_path)
        else:
            shutil.rmtree(obj_path, ignore_errors=True)

    # remove remote directory and stdout capture file
    shutil.rmtree(Remote_Data_Directory, ignore_errors=True)
    try:
        os.remove(RUNMODEL_STDOUT)
    except OSError:
        pass
            

################################################################################
# Mainline - run the simulation, check output.
################################################################################

# set logging levels
log.console_logging_level = log.INFO
setup()

# prepare user for what is about to happen
log.critical('')
log.critical('This validation requires a working internet connection to run.')
log.critical('')
log.critical('If you are behind a proxy server you will need to supply your '
             'proxy details')
log.critical('such as the proxy server address and your proxy username and '
             'password.  These')
log.critical('can be defined in one or more of the environment variables:')
log.critical('\tHTTP_PROXY')
log.critical('\tPROXY_USERNAME')
log.critical('\tPROXY_PASSWORD')
log.critical('if you wish.  If not supplied in environment variables, you '
             'will be prompted for')
log.critical('the details.')
log.critical('')
log.critical('You may still run this validation without an internet '
             'connection if you have the')
log.critical('required files.')
log.critical('*'*80)
log.critical('')

# make sure local data is up to date
if not update_local_data():
    log.info("Can't update local files over the internet (for some reason).")
    if not can_we_run():
        log.critical('')
        log.critical('*'*80)
        log.critical("Can't connect via the internet and you don't have the "
                     "required files.")
        log.critical('Terminating the validation.')
        log.critical('')
        log.critical('If you get the missing files from %s' % PATONG_DATA_URL)
        log.critical('then you can try to run the validation again.')
        sys.exit(10)

# run the simulation
run_simulation()

# check output is as expected
check_that_output_is_as_expected()

# clean up
teardown()