Changeset 2009


Ignore:
Timestamp:
16/01/07 22:47:17 (13 years ago)
Author:
astephen
Message:

Command line version separated out for actually running extraction.
Also, tried to do proper javascript in DisplayManager?.py

Location:
TI03-DataExtractor/trunk
Files:
19 added
19 edited

Legend:

Unmodified
Added
Removed
  • TI03-DataExtractor/trunk/INSTALL.txt

    r1109 r2009  
    7979python script: 
    8080 
    81 dxs/bin/DXWSInterface.py 
     81dxs/scripts/DXWSInterface.py 
    8282 
    8383You would typically run this script in the background as it should run 
    8484continuously when you want the DX server to be available: 
    8585 
    86 <BASEDIR>/dxs/bin/DXWSInterface.py & 
     86<BASEDIR>/dxs/scripts/DXWSInterface.py & 
    8787 
    8888Once this is running you should open a browser and visit the URL of 
  • TI03-DataExtractor/trunk/cgi/dxui

    r1715 r2009  
    580580            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
    581581            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    582             self.displayer._displayMainTableHeader(self.sessionID) 
     582            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return atLeastOneCheckBoxTicked("extract_info")'""") 
    583583            self.displayer._displayOptionsTable(summaryDict, optionCategories, options, optionStrings, self.sessionID, self.sessionObject) 
    584584            self.displayer._displayMainTableFooter() 
     
    592592            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
    593593            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    594             self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections("off")'""") 
     594            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections("extract_info", "off")'""") 
    595595            self.displayer._displayDomainOptions(summaryDict, optionCategories, options, optionStrings, self.sessionID) 
    596596            self.displayer._displayMainTableFooter() 
  • TI03-DataExtractor/trunk/dist/cgi/dxui

    r1225 r2009  
    1515 
    1616# Import standard library modules 
    17 import cgi, random, time, re 
     17import cgi, random, time, re, os, sys 
    1818 
    1919# Import SOAP library 
     
    2222zsiv=float("%s.%s" % zsiv[:2]) 
    2323         
     24# Get configuration file for this dx client 
     25configFile="<PLACE_CONFIG_PATH_HERE>" 
     26configPath, configFilename=os.path.split(configFile) 
     27sys.path.insert(0, configPath) 
     28exec ("from %s import *" % configFilename[:-3])   
     29           
    2430# Import package modules 
    2531from pydxc import * 
    2632 
     33# Update local pythonpath for local imports  
     34for path in LOCAL_PYTHONPATH: 
     35    sys.path.insert(0, path) 
     36 
     37# Get local security 
     38if SECURITY_MODEL=="BADC": 
     39    from BADCSecurityViaCGI import * 
     40elif SECURITY_MODEL=="NDG": 
     41    from NDGSecurityViaCGI import * 
     42 
    2743# Set up CGI error reporting if DEBUG is set to 1 in clientConfig.py module 
     44#DEBUG=1 
    2845if DEBUG==1: 
    2946    import cgitb  
     
    5168         
    5269        self.displayer=DisplayManager() 
     70 
     71        #self.displayer._displayHTTPHeader() 
    5372 
    5473        # Parse the arguments 
     
    81100        else: 
    82101            self.secureToken="undefined" 
     102 
     103        #print "Content-type: text/html\n\n" 
    83104             
    84105        # Call the dx Web Service with the arguments provided        
     
    196217             
    197218            self.args["axis_%s" % axisIndex]=iList 
    198          
     219 
     220        # Now cope with axes with only one value selected - we need a list 
     221        # Also deal with a list of strings that should be floats 
     222      
     223        for arg,value in self.args.items(): 
     224            try: 
     225                if value.find("[OPTIONAL]")>-1: 
     226                    del self.args[arg] 
     227                    continue 
     228            except: 
     229                pass 
     230 
     231            if arg[:4]=="axis": 
     232                if type(value) not in (type((1,2)), type([2,3])): 
     233                    try:  
     234                        if value.find(",")>-1: 
     235                            value=[i.strip() for i in value.split(",")] 
     236                            try: 
     237                                value=[float(i) for i in value] 
     238                            except: 
     239                                pass 
     240                            self.args[arg]=value 
     241                        else: 
     242                            raise "something" 
     243                    except: 
     244                        try: 
     245                            value=float(value) 
     246                        except: 
     247                            try: 
     248                                value=int(value) 
     249                            except: 
     250                                pass 
     251                        self.args[arg]=[value,value] 
     252                else: 
     253                    value=[i for i in value] 
     254                    try: 
     255                        value=[float(i) for i in value] 
     256                    except: 
     257                        pass 
     258                    self.args[arg]=value 
     259    
     260        # Quick fix for long list of floats where we want just the two extremes: 
     261        for arg,value in self.args.items(): 
     262            if type(value[0])==type(2.3) and len(value)>2: 
     263                value=[value[0], value[-1]] 
     264                self.args[arg]=value 
     265 
     266        # Finally, identify args coming in as "clonedomain_w.x.y.z" and clone axes 
     267        # for these. 
     268         
     269        cloneDomains=getDictSubsetMatching(self.args, "clonedomain", "regex") 
     270 
     271        for arg,value in cloneDomains.items(): 
     272            varIndex=arg.split("_")[-1] 
     273            axesToClone=getDictSubsetMatching(self.args, "axis_%s" % value, "regex") 
     274            for axkey,axvalue in axesToClone.items(): 
     275                axisIndex=axkey.split(".")[-1] 
     276                newKey="axis_%s.%s" % (varIndex, axisIndex) 
     277                self.args[newKey]=axvalue 
     278 
     279            outputFormatToClone=getDictSubsetMatching(self.args, "outputFormat", "regex") 
     280            ofkey,ofvalue=outputFormatToClone.items()[0] 
     281            newKey="outputFormat_%s" % varIndex 
     282            self.args[newKey]=ofvalue 
     283            # Delete this clonedomain item 
     284            del self.args[arg] 
     285 
    199286        #print "Content-Type: text/html\n\n" 
    200287        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()]) 
     
    214301        call the local implementation of the security. 
    215302        """ 
    216         if SECURITY_MODEL=="basic": 
    217             secChecker=SecurityViaCGI(self.username, self.password, self.secureToken) 
     303        if SECURITY_MODEL=="basic" or SECURITY_MODEL=="badc": 
     304            if SECURITY_MODEL=="basic": 
     305                secClass=SecurityViaCGI 
     306            elif SECURITY_MODEL=="badc": 
     307                secClass=BADCSecurityViaCGI 
     308 
     309            secChecker=apply(secClass, [self.username, self.password, self.secureToken]) 
    218310         
    219311            # Deal with logout 
     
    222314                secChecker.logout() 
    223315                secCheck="You have been logged out." 
     316                self.username="undefined" 
     317                self.loginStatus="out" 
    224318            else: 
    225319                secCheck=secChecker.validate()       
     
    231325                self.loginStatus="in" 
    232326                self.loginMessage="" 
     327 
    233328                (self.secureToken, self.username, self.userRoles)=secCheck 
    234329                 
    235330        elif SECURITY_MODEL=="ndg": 
    236             from NDGSecurityViaCGI import * 
     331            from pydxc.NDGSecurityViaCGI import * 
    237332            secChecker=NDGSecurityViaCGI(cookie=self.secureToken, urlArgs=self.fieldStorage) 
    238              
    239              
     333            self.loginlist=secChecker.getTrustedHostList() 
     334             
     335            #(self.secureToken, self.username, self.userRoles)= 
     336            secCheck=secChecker.validate() 
     337            if type(secCheck)==type(""): 
     338                self.loginMessage=secCheck 
     339            else: 
     340                self.loginStatus="in" 
     341                self.loginMessage="" 
     342                (self.secureToken, self.username, self.userRoles)=secCheck 
     343 
     344            #o=open("/tmp/t", "w"); o.write("%s" % repr(secCheck)); o.close() 
    240345             
    241346            # Delete field storage so not visible anywhere 
    242             del self.fieldStorage 
     347            #del self.fieldStorage 
    243348 
    244349                 
     
    248353        Web Service and calls it with the relevant arguments. 
    249354        """ 
     355        #print "Content-Type: text/html\n\n" ; print self.userRoles 
    250356        # Just print the login page if not logged in and login required 
    251357        if RESTRICTED_DATA==1 and self.loginStatus=="out": 
    252358            self.displayer._displayHTTPHeader() 
    253359            self.displayer._displayHTMLHeader() 
    254             self.displayer._displayIntroduction()            
    255             self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage) 
     360            #print "FIELD STORAGE:", self.fieldStorage 
     361            self.displayer._displayIntroduction() 
     362            #print self.loginlist            
     363            if SECURITY_MODEL in ("basic", "badc"): 
     364                self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage) 
     365            elif SECURITY_MODEL=="ndg": 
     366                argString="?" 
     367                for key in self.fieldStorage.keys(): 
     368                  if key.find("datasetURI_")>-1: 
     369                    if argString!="?":  
     370                        gapper="&" 
     371                    else: 
     372                        gapper="" 
     373                    argString=argString+("%s%s=%s" % (gapper, key, self.fieldStorage.getvalue(key))) 
     374                    if argString=="?": argString="" 
     375                self.displayer._displayNDGLoginBar(self.loginlist, argString) 
     376                # Delete field storage so not visible anywhere 
     377                del self.fieldStorage 
    256378            return       
    257                
     379                               
    258380        # Set up SOAP bindings   
    259381        if CALL_METHOD.upper()=="WS": 
     
    311433        if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None", "undefined"): 
    312434            # Start session if not known about 
     435            #print "Content-type: text/html\n\n", self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken]) 
    313436            if zsiv>=2.0: 
    314437                self.sessionID, self.secureToken=self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])[0] 
     
    342465 
    343466                self.displayer._displayHTMLHeader() 
    344                 if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
     467                if RESTRICTED_DATA==1:  
     468                    roleString=",".join(self.userRoles) 
     469                    self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+roleString) 
    345470                self.displayer._displayRequestSummaryTable(createSummaryDict(summaryString)) 
    346471                self.displayer._displayReturnLine(self.sessionID) 
    347472                return "Display footer then complete" 
    348                  
     473 
    349474            elif action=="saveRequest": 
    350475                x=self.server.callServerMethod("getDataSubsetSpecifier", 
     
    353478                #dataSubsetSpecifier, self.secureToken=x                                            
    354479                self.displayer._displayHTTPHeader()  
    355                 print x          
    356480                self.displayer._displayHTMLHeader()      
    357481                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))         
     
    372496                status, self.secureToken=self.server.callServerMethod("uploadRequest",  
    373497                                              [self.sessionID, xmlFileString, self.secureToken]) 
    374          
     498 
     499            elif action=="getStatus": 
     500                response=self.server.callServerMethod("getStatus", [self.sessionID, self.secureToken]) 
     501                if zsiv>=2.0: 
     502                    response=response[0] 
     503                 
     504                (status, errorString, outputFilePaths, self.secureToken)=response 
     505                status=status[0] 
     506                outputFilePaths=outputFilePaths[0] 
     507                 
     508                self.displayer._displayHTTPHeader() 
     509                #print outputFilePaths 
     510                self.displayer._displayHTMLHeader() 
     511                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
     512                self.displayer._displayStatus(status, errorString, self.sessionID) 
     513                if status=="complete": 
     514                    self.displayer._displayOutputFileList(outputFilePaths) 
     515                return "Display footer then complete" 
     516         
     517 
     518 
    375519           
    376520    def _getLatestOptions(self): 
     
    391535        response=self.server.callServerMethod("selectOptions", [self.sessionID, self._packArgsAsList(self.args)]) 
    392536        #self.displayer._displayHTTPHeader() 
     537        #print response, type(response) 
    393538        (optionCategories, options, optionStrings, summaryString, secureToken)=self._translateResponse(response)         
    394539        #print (optionCategories, options, optionStrings, summaryString, secureToken)    
     
    424569            optcat=optionCategories[0].split("_")[0] 
    425570         
     571        if optcat==None and (RESTRICTED_DATA==1 and summaryString.find("dataset")<0): 
     572            self.displayer._displayHTTPHeader() 
     573            self.displayer._displayHTMLHeader()   
     574            print "<P><B>You do not have the credentials to view any datasets - Sorry!</B><P>"   
     575         
    426576        # Can display simple form for these categories   
    427         if optcat in ("datasetGroup", "dataset", "variable"):             
     577        elif optcat in ("datasetGroup", "dataset", "variable"):           
    428578            self.displayer._displayHTTPHeader() 
    429579            self.displayer._displayHTMLHeader()      
    430580            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
    431581            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    432             self.displayer._displayMainTableHeader(self.sessionID) 
     582            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return atLeastOneCheckBoxTicked("extract_info")'""") 
    433583            self.displayer._displayOptionsTable(summaryDict, optionCategories, options, optionStrings, self.sessionID, self.sessionObject) 
    434584            self.displayer._displayMainTableFooter() 
     
    442592            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
    443593            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID) 
    444             self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections()'""") 
     594            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections("extract_info", "off")'""") 
    445595            self.displayer._displayDomainOptions(summaryDict, optionCategories, options, optionStrings, self.sessionID) 
    446596            self.displayer._displayMainTableFooter() 
     
    455605                self.displayer._displayDatasetSummaryLine(summaryString, optionCategories, self.sessionID)           
    456606                self.displayer._displayMainTableHeader(self.sessionID)    
    457                 print '<INPUT NAME="action" TYPE="hidden" VALUE="requestCosts">'  
     607 
     608                # Get request costs here... 
     609                response=self.server.callServerMethod("getExtractionCosts", [self.sessionID, self.secureToken]) 
     610                if zsiv>=2.0: 
     611                    response=response[0] 
     612                (estimatedDuration, estimatedVolume)=response[0:2] 
     613                summaryDict["globals"]["estimatedDuration"]=estimatedDuration 
     614                summaryDict["globals"]["estimatedVolume"]=estimatedVolume 
     615                #print '<INPUT NAME="action" TYPE="hidden" VALUE="requestCosts">'  
    458616                self.displayer._displayConfirmationSection(summaryDict) 
    459617                 
     
    478636                self.displayer._displayOutputFileList(pathList)  
    479637 
     638            elif self.args.has_key("action") and self.args["action"]=="getOutput": 
     639                self.displayer._displayHTTPHeader() 
     640                self.displayer._displayHTMLHeader() 
     641                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles)) 
     642                estimatedDuration=float(summaryDict["globals"]["estimatedDuration"]) 
     643                estimatedVolume=float(summaryDict["globals"]["estimatedVolume"]) 
     644                self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID) 
     645                response=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])  #[0] 
     646 
     647                if zsiv>=2.0: 
     648                    response=response[0] 
     649                pathList, self.secureToken=response 
     650                #print "<P>", pathList, len(pathList) 
     651                #self.displayer._displayOutputFileList(pathList) 
     652 
     653 
    480654 
    481655    def _packArgsAsList(self, args): 
  • TI03-DataExtractor/trunk/dist/install.conf

    r1109 r2009  
    117117# URL of map applet HTML page 
    118118MAP_APPLET_URL_PATH=os.path.join(WEB_EXTRAS_URL_PATH, "LiveMap_30/extractorMap.html") 
     119 
     120# LOGO_DIR: 
     121# Location of logos for the header section, this should be a 
     122# full or relative URL and NOT a directory path on your machine. 
     123LOGO_DIR=os.path.join(WEB_EXTRAS_URL_PATH, "logos") 
     124 
     125# MAP_APPLET_TEMPLATE_LOCAL_DIR: 
     126# Local path to directory holding map applet template. 
     127# Needs to be writeable from web user. 
     128MAP_APPLET_TEMPLATE_LOCAL_DIR=os.path.join(WEB_EXTRAS_LOCAL_PATH, "maps") 
     129 
     130# MAP_APPLET_TEMPLATE_URL_PATH: 
     131# URL of map applet HTML template page 
     132MAP_APPLET_TEMPLATE_URL_PATH=os.path.join(WEB_EXTRAS_URL_PATH, "maps", "map_template.html") 
     133 
     134# MAP_APPLET_TEMPLATE_LOCAL_PATH: 
     135# Local path to map applet HTML template page 
     136MAP_APPLET_TEMPLATE_LOCAL_PATH=os.path.join(MAP_APPLET_TEMPLATE_LOCAL_DIR, "map_template.html") 
     137 
  • TI03-DataExtractor/trunk/dist/install.conf.orig

    r1109 r2009  
    117117# URL of map applet HTML page 
    118118MAP_APPLET_URL_PATH=os.path.join(WEB_EXTRAS_URL_PATH, "LiveMap_30/extractorMap.html") 
     119 
     120# LOGO_DIR: 
     121# Location of logos for the header section, this should be a 
     122# full or relative URL and NOT a directory path on your machine. 
     123LOGO_DIR=os.path.join(WEB_EXTRAS_URL_PATH, "logos") 
     124 
     125# MAP_APPLET_TEMPLATE_LOCAL_DIR: 
     126# Local path to directory holding map applet template. 
     127# Needs to be writeable from web user. 
     128MAP_APPLET_TEMPLATE_LOCAL_DIR=os.path.join(WEB_EXTRAS_LOCAL_PATH, "maps") 
     129 
     130# MAP_APPLET_TEMPLATE_URL_PATH: 
     131# URL of map applet HTML template page 
     132MAP_APPLET_TEMPLATE_URL_PATH=os.path.join(WEB_EXTRAS_URL_PATH, "maps", "map_template.html") 
     133 
     134# MAP_APPLET_TEMPLATE_LOCAL_PATH: 
     135# Local path to map applet HTML template page 
     136MAP_APPLET_TEMPLATE_LOCAL_PATH=os.path.join(MAP_APPLET_TEMPLATE_LOCAL_DIR, "map_template.html") 
     137 
  • TI03-DataExtractor/trunk/dist/install.sh

    r1225 r2009  
    1 v="0.3.0" 
     1v="0.3.1" 
    22rm -rR *tar *gz README.txt *conf dx? pydx? pydx?-?.? pydx?-?-?.? cgi web_extras 
    33 
  • TI03-DataExtractor/trunk/dxc/html/header.html

    r794 r2009  
    55<link href="WEB_EXTRAS_URL_PATH/styles/home.css" rel="stylesheet" type="text/css"> 
    66 
    7 <SCRIPT language="Javascript"> 
    8  
    9 function newWindow(file,window,width,height) { 
    10     msgWindow=open(file,window,'resizable=no,width='+width+',height='+height); 
    11     if (msgWindow.opener == null) msgWindow.opener = self; 
    12 } 
    13  
    14 var help_win; 
    15      
    16 function help(url) { 
    17       help_win=window.open(url,"help_window", 
    18           "scrollbars,resizable,height=150,width=500"); 
    19       help_win.focus(); 
    20       return false; 
    21 } 
    22  
    23 function redirect(thisSelect) { 
    24     // Redirect the browser elsewhere 
    25     var idx = thisSelect.selectedIndex; 
    26     var optVal = thisSelect.options[idx].value; 
    27     if (optVal != "") location.href = optVal; 
    28 } 
    29  
    30  
    31 </SCRIPT> 
     7<SCRIPT type="text/javascript" src="WEB_EXTRAS_URL_PATH/lib/dxc.js"></SCRIPT> 
    328 
    339</HEAD> 
  • TI03-DataExtractor/trunk/dxc/scripts/csmlExampleCLClient.py

    r1244 r2009  
    1717#import readline 
    1818from ZSI.client import Binding 
    19 from pydxc.common import * 
     19from pydxc.dxcUtils import * 
    2020#from pydxc.clientConfig import SOAP_SERVER_URL 
    2121 
  • TI03-DataExtractor/trunk/dxc/scripts/exampleCLClient1.py

    r1244 r2009  
    1616#import readline 
    1717from ZSI.client import Binding 
    18 from pydxc.common import * 
     18from pydxc.dxcUtils import * 
    1919sys.path.append("../configs") 
    2020sys.path.append("dxc/configs") 
  • TI03-DataExtractor/trunk/dxc/scripts/virtualTestClient.py

    r1715 r2009  
    1616#import readline 
    1717from ZSI.client import Binding 
    18 from pydxc.common import * 
     18from pydxc.dxcUtils import * 
    1919sys.path.append("../configs") 
    2020sys.path.append("dxc/configs") 
  • TI03-DataExtractor/trunk/dxs/configs/serverConfig.py

    r1715 r2009  
    9999# The e-mail address of the adminstrator for this version.   
    100100ADMIN_MAIL_ADDRESS="as56@localhost" 
     101 
     102# MAIL_SENDER: 
     103# Who should mails to users come from? 
     104MAIL_SENDER="as56@localhost" 
    101105 
    102106# LOCAL_MAIL_HOST: 
     
    212216# MAX_NUM_DATASETS 
    213217# Maximum number of datasets allowed per request 
    214 MAX_NUM_DATASETS=2 
     218MAX_NUM_DATASETS=5 
    215219 
    216220# INPUT_DATASETS_FILE: 
     
    240244FILE_NAME_TEMPLATING=1 
    241245 
    242 # RUNNING_DIR: 
    243 # Where forked processes are noted by the server. 
    244 RUNNING_DIR=os.path.join(BASEDIR, "running") 
    245  
  • TI03-DataExtractor/trunk/dxs/dxvv/VVHadleyHadGEM1.py

    r1715 r2009  
    2323 
    2424# Import local stuff 
    25 #import sys 
    26 #sys.path.append("/home/badc/software/datasets/hadgem1/dev/cdscanning/scripts") 
    2725 
    2826class VVHadleyHadGEM1: 
     
    8179        """ 
    8280        dataFileHandler=CDMSDataHandler() 
     81 
     82        print "\nGenerating virtual variable: ", self.stash_mapping 
    8383         
    8484        inputVarDict={} 
    8585        for v in inputVarList: 
    86 #            print self.inputURI, v, axisSelectionDict, timeStep 
    87             if v=="m01s30i301" and self.inputURI.find("apa")>-1: 
    88                 inputURI=self.inputURI.replace("apa", "apm") 
     86            if v=="m01s30i301": 
     87                inputVarDict[v]=1 
    8988            else: 
    9089                inputURI=self.inputURI 
    91  
    92             inputVarDict[v]=dataFileHandler.readVariableSubsetIntoMemory(inputURI, v, axisSelectionDict, timeStep) 
     90                inputVarDict[v]=dataFileHandler.readVariableSubsetIntoMemory(inputURI, v, axisSelectionDict, timeStep) 
    9391 
    9492            exec ("%s=inputVarDict['%s']" % (v, v)) 
     
    108106 
    109107if __name__=="__main__": 
    110     x=VVHadleyHadGEM1("ua_dxvv",  "/badc/hadgem1/metadata/ensembles-hadgem1_aecaa-apa.xml", {}).var 
    111     print x.id, x, x.shape, type(x), x.attributes 
     108    ntests=2 
     109 
     110    args=sys.argv[1:] 
     111 
     112    # Populate dictionary of jobs 
     113    vvstring="""ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml cli_dxvv 
     114ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml clis_dxvv 
     115ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml cls_dxvv 
     116ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml clws_dxvv 
     117ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml clwvi_dxvv 
     118ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml hus_dxvv 
     119ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml prw_dxvv 
     120ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml rlus_dxvv 
     121ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml rsus_dxvv 
     122ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml rtmt_dxvv 
     123ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml ta_dxvv 
     124ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml ua_dxvv 
     125ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml va_dxvv 
     126ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml wap_dxvv 
     127ensembles-hadgem1-ctrl_aecaa-apm_1859-1918.xml zg_dxvv 
     128ensembles-hadgem1-ctrl_aecac-ape_1919-2098.xml rlus_dxvv 
     129ensembles-hadgem1-ctrl_aecac-ape_1919-2098.xml rsus_dxvv 
     130ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml cli_dxvv 
     131ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml clis_dxvv 
     132ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml cls_dxvv 
     133ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml clws_dxvv 
     134ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml clwvi_dxvv 
     135ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml hus_dxvv 
     136ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml prw_dxvv 
     137ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml rlus_dxvv 
     138ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml rsus_dxvv 
     139ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml rtmt_dxvv 
     140ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml ta_dxvv 
     141ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml ua_dxvv 
     142ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml va_dxvv 
     143ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml wap_dxvv 
     144ensembles-hadgem1-histanth_aebtd-apm_1859-1918.xml zg_dxvv""" 
     145 
     146    count=0 
     147    td={} 
     148 
     149    for line in vvstring.split("\n"): 
     150        count=count+1 
     151        (f, var)=line.strip().split() 
     152        f=os.path.join("/badc/hadgem1/metadata", f) 
     153        y=os.path.splitext(f)[0][-4:] 
     154        if f.find("opm")>-1 or f.find("apm")>-1: 
     155            d=16;h=0 
     156        else: 
     157            d=1;h=12 
     158        tstring="%s-1-%s %s:0:0" % (y,d,h) 
     159        td[count]=[var, f, {"axis_0.1.1.1":(0,1), "axis_0.1.1.3":(3,5)}, tstring] 
     160 
     161    if len(args)>0: 
     162        tests=[int(i) for i in args] 
     163    else: 
     164        tests=range(1, len(td.keys())) 
     165 
     166    success=[] 
     167    failure=[] 
     168 
     169    for i in tests: 
     170      try: 
     171          (a,b,c,d)=td[i] 
     172          print "\n",("-"*50),"\n\nRunning test %s with arguments:\n"%i,a,b,c,d,"\n" 
     173          x=VVHadleyHadGEM1(a,b,c,d).var 
     174          print "\n", x.id, x, x.shape, ("\n\nTest %s ran successfully."%i) 
     175          success.append([i]) 
     176      except Exception, err: 
     177          failure.append([i, a, b, err.args]) 
     178 
     179    print "="*40      
     180    print "\nRan %s tests. %s succeeded. %s failed.\n" % (len(tests), len(success), len(failure)) 
     181 
     182    if len(failure)>0: 
     183       print "\nFailures were:\n" 
     184       for i in failure: print i 
  • TI03-DataExtractor/trunk/pydxc/CGIErrorHandler.py

    r794 r2009  
    1818# import local modules 
    1919from clientConfig import * 
    20 from common import * 
     20from dxcUtils import * 
    2121 
    2222 
  • TI03-DataExtractor/trunk/pydxc/DisplayManager.py

    r1715 r2009  
    1717# Import package modules 
    1818from clientConfig import * 
    19 from common import * 
     19from dxcUtils import * 
    2020import DateTimeManager 
    21 import jsFunctions 
     21import axisGrouperLogic 
     22#import jsFunctions 
    2223 
    2324 
     
    198199        itemTitle=itemMap[optionCategories[0].split("_")[0]] 
    199200        print """<P><FONT COLOR="black"><B>PLEASE SELECT: %s</B> (<A NAME="selectAll"  
    200 onclick="selectAllCheckBoxes()">  select all </A> / <A NAME="deSelectAll"  
    201 onclick="deSelectAllCheckBoxes()"> deselect all </A> )</FONT><P>""" % itemTitle  
     201onclick='selectAllCheckBoxes("extract_info")'>  select all </A> / <A NAME="deSelectAll"  
     202onclick='deSelectAllCheckBoxes("extract_info")'> deselect all </A> )</FONT><P>""" % itemTitle  
    202203         
    203204        # Insert useful select all javascript function for checkboxes 
    204         print jsFunctions.js_selectAllCheckBoxes 
    205         print jsFunctions.js_deSelectAllCheckBoxes 
     205        #print jsFunctions.js_selectAllCheckBoxes 
     206        #print jsFunctions.js_deSelectAllCheckBoxes 
     207         
     208        # Write JS for making sure checks are done for at least one being ticked 
     209        print """<SCRIPT type="text/javascript">  
     210var doValidateCheckBoxes=1; 
     211        </SCRIPT>""" 
    206212         
    207213        if itemTitle=="Dataset Group": 
     
    213219                discoveryMetadataLinks=[i[1][1] for i in options] 
    214220 
    215                 selectedFlag=None                   
     221                selectedFlag=1              
    216222                for i in range(len(selectionIDs)): 
    217223                    selectionID=selectionIDs[i] 
     
    237243                itemValues=options 
    238244                itemNames=optionStrings 
    239                 selectedFlag=None  
     245                selectedFlag=1  
    240246                 
    241247                lastDatasetGroup="WON'T MATCH"              
     
    266272                itemValues=[i[0] for i in options] 
    267273                itemNames=[i[1] for i in optionStrings] 
    268                 selectedFlag=None  
     274                selectedFlag=1  
    269275                 
    270276                lastDataset="WON'T MATCH" 
     
    308314        """      
    309315        # Define a bucket to store axis info in for later 
    310         axisBucket=[[],[],[]] 
     316        """axisBucket=[[],[],[]] 
    311317        formatDict={} 
    312318        counter=0 
     
    321327         
    322328        # define which variables have the same axes 
    323         sameBucket=getIdenticalDomains(axisBucket) 
    324          
     329        sameBucket=getIdenticalDomains(axisBucket)""" 
     330         
     331        (sameBucket, axisBucket, formatDict)=axisGrouperLogic.rejigOptions(optionCategories, options, optionStrings) 
    325332        (optionCategories, options, optionStrings)=axisBucket 
    326333         
    327334        # Predefine what we need for the axis selection in terms of interfaces... 
    328         knownAxisDict={}                 
     335        """knownAxisDict={}              
    329336        axisDict={} 
    330337         
     
    333340        minValues=[] 
    334341        maxValues=[]     
    335  
     342        """ 
     343        (minNames, minValues, maxValues, knownAxisDict, axisDict)=axisGrouperLogic.getDictsAndJSVars(optionCategories, options, optionStrings) 
    336344        # Loop through keys to get varIndices in order   
    337         for i in range(len(optionCategories)): 
     345        """for i in range(len(optionCategories)): 
    338346            optionName=optionCategories[i] 
    339347            varIndex=".".join(optionName.split(".")[:-1])[5:] 
     
    353361                    maxValues.append(endTime[:]) 
    354362             
    355             axisDict[varIndex]["axes"].append([optionName, items]) 
     363            axisDict[varIndex]["axes"].append([optionName, items])""" 
    356364               
    357365        axisDictKeys=axisDict.keys() 
     
    359367         
    360368        # Now print javascript time functions if needed 
    361         if len(minNames)>0: 
     369        axisGrouperLogic.renderJSVars(minNames, minValues, maxValues) 
     370        """if len(minNames)>0: 
    362371            minNames=str(minNames) 
    363372            minValues=str([list(lst) for lst in minValues]) 
    364373            maxValues=str([list(lst) for lst in maxValues]) 
    365             print jsFunctions.js_timeValidationFunctions % (minNames, minValues, maxValues) 
     374            #print jsFunctions.js_timeValidationFunctions % (minNames, minValues, maxValues) 
     375            print """ 
     376#<SCRIPT type="text/javascript"> 
     377#var minNames=%s;  
     378#var maxNames=minNames; 
     379#var minValues=%s; 
     380#var maxValues=%s; 
     381#</SCRIPT> 
     382#""" % (minNames, minValues, maxValues) 
    366383         
    367384        # Print options stuff    
     
    375392 
    376393        # Define massive string that will hold all html to show ALL var domains  
    377         print1="" 
    378         print1=print1+ """<TABLE ID="domainTable">\n""" 
    379         print1=print1+ """<TR CLASS="tablestyle"> 
     394        jsString="""<TABLE ID="domainTable"> 
     395                      <TR CLASS="tablestyle"> 
    380396                        <TD><B>AXIS NAME</B></TD> 
    381397                        <TD><B>RECOGNISED AS</B></TD> 
     
    383399                        <TD COLSPAN="3"><B>SELECTION</B></TD> 
    384400                        <TD><B>INFORMATION</B></TD></TR>\n"""    
    385          
     401                         
     402        # Now create a string holding all the html for grouping domains for similar variables                    
     403                         
     404        # PROTO JS 
     405        jsstringREADY="""var domainTable=createHTMLTable([], ["id"], ["domainTable"]); 
     406 
     407var row1=createHTMLTableRow([],["CLASS"], ["tablestyle"]); 
     408domainTable.addRow(row1); 
     409 
     410var c1=createHTMLTableCell(createText("AXIS NAME", "B"),[],[]); 
     411var c2=createHTMLTableCell(createText("RECOGNISED AS", "B"),[],[]); 
     412var c3=createHTMLTableCell(createText("UNITS", "B"),[],[]); 
     413var c4=createHTMLTableCell(createText("SELECTION", "B"),["COLSPAN"],["3"]); 
     414var c5=createHTMLTableCell(createText("INFORMATION", "B"),[],[]); 
     415 
     416var cells=[c1,c2,c3,c4,c5]; 
     417 
     418for (var i=0; i<5: i++) { 
     419    addCell(row1, cells[i]); 
     420} 
     421         
     422""" 
     423                         
    386424        # loop through axis dictionary contents and render each axis 
    387425        # according to what we have learnt about it 
     426                 
     427        ungrouped=jsString 
     428         
    388429        for key in axisDictKeys: 
    389430 
     
    393434            datasetGroup=summaryDict["datasetGroups"][dsgKey] 
    394435            dataset=summaryDict["datasets"]["%s.%s" % (dsgKey, dsKey)] 
    395             print1=print1+ """<TR><TD COLSPAN="7">&nbsp;</TD></TR>\n"""  
    396             print1=print1+ """<TR CLASS="tablestyle"><TD COLSPAN="7"><B>%s &gt;&gt;&gt; %s &gt;&gt;&gt; %s</TD></TR>\n""" % (datasetGroup, dataset, varID)           
     436             
     437                     
     438            ungrouped+="""<TR><TD COLSPAN="7">&nbsp;</TD></TR>   
     439                <TR CLASS="tablestyle"> 
     440                <TD COLSPAN="7"><B>%s &gt;&gt;&gt; %s &gt;&gt;&gt; %s</TD></TR>\n""" % (datasetGroup, dataset, varID) 
    397441         
    398442            # get sub-dictionary for this variable 
     
    410454                    found[ax]=d[ax] 
    411455             
     456            ungrouped+=self._addAxesAndFormatRenderingToString(axes, found, key, formatDict) 
     457 
     458        grouped=jsString 
     459         
     460        # Now do the grouped bucket 
     461        varsAlreadyGrouped=[] 
     462        for key in axisDictKeys: 
     463 
     464            varIndices=re.match("(\d+\.\d+\.\d+)", key).groups()[0] 
     465             
     466            if varIndices in varsAlreadyGrouped: continue 
     467             
     468            varsToLoop=[key] 
     469            for sameVars in sameBucket: 
     470                if ("variable_"+varIndices) in sameVars: 
     471                    varsToLoop=[i.split("_")[-1] for i in sameVars] 
     472                    varsAlreadyGrouped=varsAlreadyGrouped+varsToLoop 
     473                    break 
     474             
     475            if len(varsToLoop)>1: 
     476                domainFlag="SAME DOMAIN: " 
     477            else: 
     478                domainFlag="" 
     479                 
     480            grouped+="""<TR><TD COLSPAN="7">&nbsp;</TD></TR>\n""" 
     481             
     482            for vkey in varsToLoop: 
     483                varID=summaryDict["variables"][vkey] 
     484                (dsgKey, dsKey, varKey)=re.match("(\d+)\.(\d+)\.(\d+)", key).groups()        
     485                datasetGroup=summaryDict["datasetGroups"][dsgKey] 
     486                dataset=summaryDict["datasets"]["%s.%s" % (dsgKey, dsKey)]       
     487                 
     488                grouped+="""<TR CLASS="tablestyle"><TD COLSPAN="7"><B>%s%s &gt;&gt;&gt; %s &gt;&gt;&gt; %s</TD></TR>\n""" % (domainFlag, datasetGroup, dataset, varID) 
     489                # Create hidden field for cloning domain 
     490                if vkey!=varsToLoop[0]: 
     491                    grouped+=("""<INPUT TYPE="hidden" NAME="clonedomain_%s" VALUE="%s"/>""" % (vkey, varsToLoop[0])) 
     492         
     493            d=axisDict[key] 
     494            axes=d["axes"] 
     495             
     496            found={} 
     497            # Check time, lat and lon 
     498            for ax in ("time", "latitude", "longitude"): 
     499                if d.has_key(ax): 
     500                    found[ax]=d[ax] 
     501 
     502            grouped+=self._addAxesAndFormatRenderingToString(axes, found, key, formatDict) 
     503         
     504        grouped+="""</TABLE>\n""" 
     505        ungrouped+="""</TABLE>\n"""      
     506 
     507        grouped=grouped.replace("\"", "\\\"") 
     508        ungrouped=ungrouped.replace("\"", "\\\"") 
     509         
     510        print "</DIV>" 
     511 
     512        print """<SCRIPT type="text/javascript"> 
     513         
     514        function toggleDomainGrouping(grouper) { 
     515            var domainElement=document.getElementById("domainSelection"); 
     516            var ungrouped="";  
     517            var grouped=""; """ 
     518             
     519        for line in ungrouped.split("\n"): 
     520            print """            ungrouped+="%s"; """ % line         
     521             
     522        for line in grouped.split("\n"): 
     523            print """            grouped+="%s"; """ % line 
     524                 
     525        print """            if (grouper=="off") {      
     526                 domainElement.innerHTML=ungrouped;  
     527            } else { 
     528                 domainElement.innerHTML=grouped; 
     529            } 
     530            validateAllTimeSelections("extract_info", "off"); 
     531        } 
     532        toggleDomainGrouping("off"); 
     533 
     534            </SCRIPT> """ 
     535 
     536        print """<P><INPUT TYPE="checkbox" NAME="multipleFileOutput"> 
     537               &nbsp;Use multiple output files [ this is the default large files as limited by the server ].""" 
     538 
     539 
     540    def _addAxesAndFormatRenderingToString(self, axisList, foundDict, axisDictKey, formatDict): 
     541        """ 
     542        Loops through the axes adding them to the appropriate string. 
     543        """ 
     544        cs="" 
     545        axes=axisList 
     546        found=foundDict 
     547        key=axisDictKey 
     548        formatDict=formatDict 
     549                 
     550        if 1: 
    412551            # loop through all the axes and render them appropriately 
    413552            for axis in axes: 
     
    454593                    #print '<B>Horizontal Domain</B><P>' 
    455594                      
    456                     print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     595                    cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    457596                     <TD>%s</TD> 
    458597                     <TD>%s</TD> 
     
    469608                    mapHTMLFile=self._checkMapAppletHTMLPage(lonOptionName, latOptionName) 
    470609                     
    471                     print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     610                    cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    472611                     <TD>%s</TD> 
    473612                     <TD>%s</TD>                      
     
    481620                                   easternExtent)   
    482621                                                     
    483                     print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     622                    cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    484623                     <TD>%s</TD> 
    485624                     <TD>%s</TD>                      
     
    496635                    (calendar, start,end,intervalValue)=items[5:9] 
    497636                     
    498                      
    499                     print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     637                    cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    500638                     <TD>%s</TD> 
    501639                     <TD>%s</TD>\n""" % (longName, knownAxis, units) 
    502640 
    503                     print1=print1+self._displayTemporalDomainMenus(start, end, intervalValue, units, calendar,optionName) 
    504                     print1=print1+ """<TD><INPUT TYPE="button" NAME="validateTime" VALUE="Validate time selections" onClick='validateTimeSelections("%s")'/></TD></TR>\n""" % optionName 
     641                    cs+=self._displayTemporalDomainMenus(start, end, intervalValue, units, calendar,optionName) 
     642                     
     643                    cs+="""<TD><INPUT TYPE="button" NAME="validateTime" VALUE="Validate time selections" onClick='validateTimeSelections("extract_info", "%s")'/></TD></TR>\n""" % optionName 
    505644                              
    506                             
    507                     """<TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    508                      <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&nbsp;<B>Low</B></TD><TD ALIGN="RIGHT"><B>High</B>&nbsp;</TD></TR></TABLE></TD>                       
    509                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    510                      </TR>""" #% (optionName+"_low", start, optionName+"_high", end)    
    511645                 
    512646                # else deal with other axis types, noting that these also vary             
     
    532666                        if len(uniqueList)<5:  
    533667                            hght=len(uniqueList) 
    534                         print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     668                        cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    535669                           <TD>%s</TD> 
    536670                           <TD>%s</TD> 
     
    558692                        fullList=items[6:] 
    559693                        optionsAsString="\n".join(["<OPTION>%s</OPTION>" % i for i in fullList]) 
    560                         print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     694                        cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    561695                           <TD>%s</TD> 
    562696                           <TD>%s</TD> 
     
    570704                    else: 
    571705                        start,end=items[6:8] 
    572                         print1=print1+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
     706                        cs+="""<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    573707                     <TD>%s</TD> 
    574708                     <TD>%s</TD>                      
     
    578712                     </TR>\n""" % (longName, knownAxis, units,  
    579713                     optionName+"_low", start, optionName+"_high", end)    
    580  
    581             # Display output format  
    582             print1=print1+ """<TR><TD WIDTH="20%%"><B>OUTPUT FORMAT</B></TD>\n""" 
    583             print1=print1+ """<TD COLSPAN="3">Note that you should choose NetCDF format if you wish to visualise data.</TD>\n"""                      
    584             print1=print1+ '<TD COLSPAN="3"><SELECT NAME="outputFormat_%s">\n' % key 
    585             for format in formatDict["outputFormat_%s" % varIndex]: 
    586                 print1=print1+ "<OPTION>%s</OPTION>\n" % format 
    587             print1=print1+ "</SELECT></TD>\n" 
    588              
    589         # Now create a string holding all the html for grouping domains for similar variables 
    590         print2="" 
    591         print2=print2+ """<TABLE ID="domainTable">\n""" 
    592         print2=print2+ """<TR CLASS="tablestyle"> 
    593                         <TD><B>AXIS NAME</B></TD> 
    594                         <TD><B>RECOGNISED AS</B></TD> 
    595                         <TD><B>UNITS</B></TD> 
    596                         <TD COLSPAN="3"><B>SELECTION</B></TD> 
    597                         <TD><B>INFORMATION</B></TD></TR>\n"""    
    598          
    599         # Now do the grouped bucket 
    600         varsAlreadyGrouped=[] 
    601         for key in axisDictKeys: 
    602  
    603             varIndices=re.match("(\d+\.\d+\.\d+)", key).groups()[0] 
    604              
    605             if varIndices in varsAlreadyGrouped: continue 
    606              
    607             varsToLoop=[key] 
    608             for sameVars in sameBucket: 
    609                 if ("variable_"+varIndices) in sameVars: 
    610                     varsToLoop=[i.split("_")[-1] for i in sameVars] 
    611                     varsAlreadyGrouped=varsAlreadyGrouped+varsToLoop 
    612                     break 
    613              
    614             if len(varsToLoop)>1: 
    615                 domainFlag="SAME DOMAIN: " 
    616             else: 
    617                 domainFlag="" 
    618                  
    619             print2=print2+ """<TR><TD COLSPAN="7">&nbsp;</TD></TR>\n""" 
    620              
    621             for vkey in varsToLoop: 
    622                 varID=summaryDict["variables"][vkey] 
    623                 (dsgKey, dsKey, varKey)=re.match("(\d+)\.(\d+)\.(\d+)", key).groups()        
    624                 datasetGroup=summaryDict["datasetGroups"][dsgKey] 
    625                 dataset=summaryDict["datasets"]["%s.%s" % (dsgKey, dsKey)]       
    626                 print2=print2+ """<TR CLASS="tablestyle"><TD COLSPAN="7"><B>%s%s &gt;&gt;&gt; %s &gt;&gt;&gt; %s</TD></TR>\n""" % (domainFlag, datasetGroup, dataset, varID) 
    627                 # Create hidden field for cloning domain 
    628                 if vkey!=varsToLoop[0]: 
    629                     print2=print2+ ("""<INPUT TYPE="hidden" NAME="clonedomain_%s" VALUE="%s"/>""" % (vkey, varsToLoop[0])) 
    630          
    631             d=axisDict[key] 
    632             axes=d["axes"] 
    633              
    634             found={} 
    635             # Check time, lat and lon 
    636             for ax in ("time", "latitude", "longitude"): 
    637                 if d.has_key(ax): 
    638                     found[ax]=d[ax] 
    639  
    640             # loop through all the axes and render them appropriately        
    641             for axis in axes: 
    642                 (optionName, items)=axis 
    643                 varIndex=".".join(optionName.split(".")[:-1])[5:] 
    644                 axisIndex=int(optionName.split(".")[-1]) 
    645                 [knownAxis, id, longName, units, listType, unused]=items[:6] 
    646  
    647                 # if latitude or longitude then render both in one code block 
    648                 if (found.has_key("latitude") and found.has_key("longitude")) and \ 
    649                         axisIndex in (found["latitude"], found["longitude"]): 
    650                  
    651                     if found.has_key("used lat lon"):  continue 
    652                  
    653                     if axisIndex==found["latitude"]: 
    654                         # The current axis is latitude so need to get longitude 
    655                         latItems=items           
    656                         latOptionName=optionName         
    657                         lonIndex=found["longitude"] 
    658                          
    659                         for x in axes: 
    660                             if int(x[0].split(".")[-1])==lonIndex: 
    661                                 # Found longitude axis in list 
    662                                 (lonOptionName, lonItems)=x                      
    663                          
    664                     elif axisIndex==found["longitude"]: 
    665                         # The current axis is longitude so need to get latitude 
    666                         lonItems=items 
    667                         lonOptionName=optionName                         
    668                         latIndex=found["latitude"] 
    669                          
    670                         for x in axes: 
    671                             if int(x[0].split(".")[-1])==latIndex: 
    672                                 # Found latitude axis in list 
    673                                 (latOptionName, latItems)=x              
    674                                                                  
    675                     [latKnownAxis, latId, latLongName, latUnits, latListType, latUnused]=latItems[:6] 
    676                     northernExtent, southernExtent=latItems[6:8] 
    677                     [lonKnownAxis, lonId, lonLongName, lonUnits, lonListType, lonUnused]=lonItems[:6] 
    678                     westernExtent, easternExtent=lonItems[6:8] 
    679      
    680                     found["used lat lon"]=1 
    681                       
    682                     #print '<B>Horizontal Domain</B><P>' 
    683                       
    684                     print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    685                      <TD>%s</TD> 
    686                      <TD>%s</TD> 
    687                      <TD></TD>                                
    688                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/><BR></TD> 
    689                      <TD><B></B></TD> 
    690                      <TD WIDTH="30%%"><FONT SIZE="-2"><B>NOTE ABOUT THE JAVA MAP APPLET:</B>  
    691 <BR>1. The map will not work if you do not have Java enabled on your browser.</FONT></TD> 
    692                      </TR>\n""" % (latLongName, latKnownAxis, latUnits,  
    693                                    latOptionName+"_high", northernExtent)   
    694                                                                               
    695                                                                               
    696                     # Check existence of map applet page for this axis ID, otherwise make it 
    697                     mapHTMLFile=self._checkMapAppletHTMLPage(lonOptionName, latOptionName) 
    698                      
    699                     print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    700                      <TD>%s</TD> 
    701                      <TD>%s</TD>                      
    702                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    703                      <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&nbsp;<B></B></TD><TD><CENTER><B><input type="button" value="Select from map" 
    704     onClick="newWindow('%s','window2',550,400);"></CENTER></TD></TR></TABLE></TD>                     
    705                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    706                      <TD><BR><FONT SIZE="-2">2. This applet is known not to work on certain browsers: Mozilla, Konqueror.</FONT></TD> 
    707                      </TR>\n""" % (lonLongName, lonKnownAxis, lonUnits,  
    708                                    lonOptionName+"_low", westernExtent, mapHTMLFile, lonOptionName+"_high", 
    709                                    easternExtent)   
    710                                                      
    711                     print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    712                      <TD>%s</TD> 
    713                      <TD>%s</TD>                      
    714                      <TD></TD>                                
    715                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    716                      <TD><B>&nbsp;</B></TD> 
    717                      <TD><FONT SIZE="-2"> 
    718 <BR>3. On some browsers you may have to select your subset twice before it registers.</FONT></TD> 
    719                      </TR>\n""" % ("","","",  
    720                                    latOptionName+"_low", southernExtent)                     
    721  
    722                 # if time then render that in a particular way 
    723                 elif found.has_key("time") and axisIndex==found["time"]: 
    724                     (calendar, start,end,intervalValue)=items[5:9] 
    725                      
    726                      
    727                     print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    728                      <TD>%s</TD> 
    729                      <TD>%s</TD>\n""" % (longName, knownAxis, units) 
    730  
    731                     print2=print2+self._displayTemporalDomainMenus(start, end, intervalValue, units, calendar,optionName) 
    732                     print2=print2+ """<TD><INPUT TYPE="button" NAME="validateTime" VALUE="Validate time selections" onClick='validateTimeSelections("%s")'/></TD></TR>\n""" % optionName 
    733                               
    734                             
    735                     """<TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    736                      <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&nbsp;<B>Low</B></TD><TD ALIGN="RIGHT"><B>High</B>&nbsp;</TD></TR></TABLE></TD>                       
    737                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    738                      </TR>""" #% (optionName+"_low", start, optionName+"_high", end)    
    739                  
    740                 # else deal with other axis types, noting that these also vary             
    741                 else: 
    742                     listType=items[4] 
    743                     if len(unused)>0:  
    744                         comment=unused 
    745                     else: 
    746                         comment="" 
    747  
    748                     # render axis according to the type of list sent 
    749                     # "full list" is all the numbers 
    750                     # "comma-separated ..." is a text box for user to input text into 
    751                     # all others are rendered as two input boxes, one low and one high 
    752                     if listType=="full list": 
    753                         fullList=items[6:] 
    754                         uniqueList=[] 
    755                         for i in fullList:  
    756                             if i not in uniqueList: 
    757                                 uniqueList.append(i) 
    758                         optionsAsString="\n".join(["<OPTION>%s</OPTION>" % i for i in uniqueList]) 
    759                         hght=5 
    760                         if len(uniqueList)<5:  
    761                             hght=len(uniqueList) 
    762                         print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    763                            <TD>%s</TD> 
    764                            <TD>%s</TD> 
    765                            <TD COLSPAN="3"><CENTER> 
    766                            <SELECT NAME="%s" SIZE="%s" MULTIPLE="multiple"> 
    767                              %s 
    768                            </SELECT> 
    769                            </TD> 
    770                            <TD><FONT SIZE="-2"><B>NOTE ABOUT THIS SELECTION CATEGORY:</B><BR>%s</FONT></TD> 
    771                            </TR>\n""" % (longName, knownAxis, units, optionName, hght, optionsAsString, comment) 
    772  
    773                     # or deal with comma-separated input in text box 
    774                     elif listType.split()[0]=="comma-separated": 
    775                         # Render a textarea with option to insert text 
    776                         cs,lts=listType.split() 
    777                         if lts.find("integer")>-1: 
    778                             ntype="Integer" 
    779                             nlength=lts[7:] 
    780                         elif lts.find("float")>-1: 
    781                             ntype="Float" 
    782                             nlength=lts[5:] 
    783  
    784                         taString="[OPTIONAL] You can insert values here following the format: \n%s %ss of length %s." % (cs.title(), ntype.lower(), nlength) 
    785  
    786                         fullList=items[6:] 
    787                         optionsAsString="\n".join(["<OPTION>%s</OPTION>" % i for i in fullList]) 
    788                         print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    789                            <TD>%s</TD> 
    790                            <TD>%s</TD> 
    791                            <TD COLSPAN="3"><CENTER> 
    792                            <TEXTAREA NAME="%s" ROWS="5" COLS="50">%s</TEXTAREA> 
    793                            </TD> 
    794                            <TD><FONT SIZE="-2"><B>NOTE ABOUT THIS SELECTION CATEGORY:</B><BR>%s</FONT></TD> 
    795                            </TR>\n""" % (longName, knownAxis, units, optionName, taString, comment) 
    796  
    797                     # or deal with (low, high) range  
    798                     else: 
    799                         start,end=items[6:8] 
    800                         print2=print2+ """<TR><TD WIDTH="20%%"><B>%s</B></TD> 
    801                      <TD>%s</TD> 
    802                      <TD>%s</TD>                      
    803                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    804                      <TD><TABLE BORDER="0"><TR><TD ALIGN="LEFT">&lt;&nbsp;<B>Low</B></TD><TD ALIGN="RIGHT"><B>High</B>&nbsp;&gt;</TD></TR></TABLE></TD>               
    805                      <TD><INPUT TYPE="text" NAME="%s" VALUE="%s"/></TD> 
    806                      </TR>\n""" % (longName, knownAxis, units,  
    807                      optionName+"_low", start, optionName+"_high", end)    
    808  
    809             # Display output format  
    810             print2=print2+ """<TR><TD WIDTH="20%%"><B>OUTPUT FORMAT</B></TD>\n""" 
    811             print2=print2+ """<TD COLSPAN="3">Note that you should choose NetCDF format if you wish to visualise data.</TD>\n"""                      
    812             print2=print2+ '<TD COLSPAN="3"><SELECT NAME="outputFormat_%s">\n' % key 
    813             for format in formatDict["outputFormat_%s" % varIndex]: 
    814                 print2=print2+ "<OPTION>%s</OPTION>\n" % format 
    815             print2=print2+ "</SELECT></TD>\n" 
    816  
    817         print1=print1+ """</TABLE>\n"""     
    818         print2=print2+ """</TABLE>\n""" 
    819         #print print1 
    820         print "</DIV>" 
    821  
    822         escapedprint1=print1.replace("\"", "\\\"") 
    823         escapedprint2=print2.replace("\"", "\\\"") 
    824  
    825         print """<SCRIPT language="javascript"> 
    826         function toggleDomainGrouping(grouper) { 
    827             var domainElement=document.getElementById("domainSelection"); 
    828             var ungrouped="";  
    829             var grouped=""; """ 
    830         for line in escapedprint1.split("\n"): 
    831             print """            ungrouped+="%s"; """ % line         
    832              
    833         for line in escapedprint2.split("\n"): 
    834             print """            grouped+="%s"; """ % line 
    835                  
    836         print """            if (grouper=="off") {      
    837                  domainElement.innerHTML=ungrouped;  
    838             } else { 
    839                  domainElement.innerHTML=grouped; 
    840             } 
    841             validateAllTimeSelections("off"); 
    842         } 
    843         toggleDomainGrouping("off"); 
    844  
    845             </SCRIPT> """ 
    846  
    847         print """<P><INPUT TYPE="checkbox" NAME="multipleFileOutput"> 
    848                &nbsp;Use multiple output files [ this is the default large files as limited by the server ].""" 
    849  
    850         #print """<SCRIPT language="Javascript">validateAllTimeSelections("off");</SCRIPT>""" 
    851                 
     714                         
     715        # Display output format  
     716        cs+="""<TR><TD WIDTH="20%%"><B>OUTPUT FORMAT</B></TD>\n""" 
     717        cs+="""<TD COLSPAN="3">Note that you should choose NetCDF format if you wish to visualise data.</TD>\n"""                     
     718        cs+="""<TD COLSPAN="3"><SELECT NAME="outputFormat_%s">\n""" % key 
     719         
     720        for format in formatDict["outputFormat_%s" % varIndex]: 
     721            cs+="<OPTION>%s</OPTION>\n" % format 
     722        cs+="</SELECT></TD>\n"           
     723        return cs 
     724 
    852725 
    853726    def  _checkMapAppletHTMLPage(self, lonAxisID, latAxisID): 
     
    11711044 
    11721045         
    1173     def DEPRACATED_displayTemporalDomainOptions(self, options): 
    1174         """ 
    1175         Prints a form entry for specifying the temporal domain. 
    1176         """   
    1177         # timeDict holds time list dictionaries for start and end times,  
    1178         # time units and time interval for each dataset 
    1179         timeDict={} 
    1180         for dsetNumber in range(1, self.numberOfDatasets+1): 
    1181             (start_time, end_time, (intervalValue, intervalUnits))=options[dsetNumber-1] 
    1182             timeDict["dataset_%s" % dsetNumber]=(start_time, end_time, intervalValue, intervalUnits)  
    1183   
    1184         super_index_list=[] 
    1185         timeBins={} 
    1186         for dsetNumber in range(1, self.numberOfDatasets+1): 
    1187             (start_time, end_time, intervalValue, intervalUnits)=timeDict["dataset_%s" % dsetNumber] 
    1188             index_list=[] 
    1189             # Get the bin list for all times 
    1190             timeList=DateTimeManager.createList(start_time, end_time, (intervalValue, intervalUnits), listtype="tuple") 
    1191             timeBins[dsetNumber]=DateTimeManager.getTimeBins(timeList) 
    1192             for i in range(len(start_time)): 
    1193                 index_list.append(timeBins[dsetNumber][i].index(start_time[i])) 
    1194             super_index_list=super_index_list+index_list[:]+index_list[:]  
    1195  
    1196         # Insert javascript functions to do date checking. 
    1197         if len(super_index_list)==12:  super_index_list=super_index_list+[0,0,0,0,0,0,0,0,0,0,0,0] 
    1198         print jsFunctions.js_dateCheckFunctionGroup % tuple(super_index_list)      
    1199  
    1200         # Temporal domain 
    1201         print '<P><B>Time</B><P><TABLE WIDTH="100%"><TR>' 
    1202         for dsetNumber in range(1, self.numberOfDatasets+1): 
    1203             (intervalValue, intervalUnits)=timeDict["dataset_%s" % dsetNumber][2:] 
    1204             (start_time, end_time)=timeDict["dataset_%s" % dsetNumber][:2] 
    1205             print '<INPUT NAME="timeIntervalUnits_%s" TYPE="hidden" VALUE="%s">' % (dsetNumber, intervalUnits)  
    1206             print '<INPUT NAME="timeIntervalValue_%s" TYPE="hidden" VALUE="%s">' % (dsetNumber, intervalValue) 
    1207             print '<TD WIDTH="50%">' 
    1208             print '<TABLE BORDER="1"><TR>' 
    1209  
    1210             for part in ("Dataset %s: Start time" % dsetNumber, "start", "text", "end", "End time"): 
    1211                 if part in ("Dataset %s: Start time" % dsetNumber, "End time"): 
    1212                     print '<TD COLSPAN="6">%s</TD>' % part 
    1213                 else: 
    1214                   fieldFlag="" 
    1215                   count=0 
    1216                   for key in TIME_KEYS: 
    1217                     if part=="text": 
    1218                         print "<TD>%s</TD>" % key 
    1219                     elif part in ("start", "end"): 
    1220                         print """<TD><SELECT NAME="%s%s_%s" %s onChange="checkDate('%s_%s')">""" % (part,  
    1221                                    key, dsetNumber, fieldFlag, part, dsetNumber) 
    1222                         if key=="year": 
    1223                             timeFormat="%.4d" 
    1224                         else: 
    1225                             timeFormat="%.2d" 
    1226  
    1227                         for item in timeBins[dsetNumber][count]: 
    1228                             timeItem=timeFormat % item 
    1229                             print """<OPTION VALUE="%s">%s</OPTION>""" % (timeItem, timeItem) 
    1230                  
    1231                         print "</SELECT></TD>" 
    1232                         count=count+1 
    1233  
    1234                 print "</TR>" 
    1235             print "</TABLE>" 
    1236             print "</TD>" 
    1237  
    1238         print "</TR></TABLE><P>" 
    1239         # Call the javascript to update the date field at start 
    1240         print """<SCRIPT LANGUAGE="Javascript">resetAllDates(%s)</SCRIPT>""" % (dsetNumber-1)     
    1241          
    1242  
    12431046 
    12441047 
     
    14261229                 <INPUT TYPE="submit" NAME="statusGetter" VALUE="Check Status"/> 
    14271230                 </FORM></P>""" % (CGI_SCRIPT_URL_PATH, sessionID) 
     1231             
     1232            print """<P><B>This page will reload every 5 seconds.</B></P> 
     1233              <SCRIPT TYPE="text/javascript">setTimeout("location.reload()", 5000)</SCRIPT>""" 
    14281234                     
    14291235 
     
    14971303                 <INPUT TYPE="submit" NAME="statusGetter" VALUE="Check Status"/> 
    14981304                 </FORM></P>""" % (CGI_SCRIPT_URL_PATH, sessionID) 
    1499  
     1305                               
    15001306 
    15011307    def _displayFileNameRuleOptions(self): 
  • TI03-DataExtractor/trunk/pydxc/WSCaller.py

    r1715 r2009  
    2020# Import package modules 
    2121from clientConfig import * 
    22 from common import * 
     22from dxcUtils import * 
    2323from DisplayManager import DisplayManager 
    2424 
  • TI03-DataExtractor/trunk/pydxs/DXController.py

    r1715 r2009  
    1717 
    1818# Bring package into local scope 
    19 from serverConfig import BASEDIR, RUNNING_DIR 
     19from serverConfig import BASEDIR 
    2020sys.path.insert(0, os.path.split(BASEDIR)[0]) 
    2121sys.path.insert(0, "..") 
     
    4444    """ 
    4545     
    46     def __init__(self, args): 
     46    def __init__(self, args, runLocally="no"): 
    4747        """ 
    4848        Takes in a group of arguments and then calls the appropriate 
     
    5858        self.secureToken="undefined" 
    5959        self.error=None 
    60         self.fork=None 
    61         self.status="undefined" 
     60        self.status="constructing" 
    6261 
    6362        # Parse the arguments 
     
    6968        # If switched on check security         
    7069        if self.error==None: 
    71             if RESTRICTED_DATA==1: 
     70            if RESTRICTED_DATA==1 and runLocally!="yes": 
    7271                try: 
    7372                    self._checkSecurity() 
     
    8584                raise DXSessionObjectError, error    
    8685 
    87         try: 
    88             self.statusFile=os.path.join(RUNNING_DIR, self.bag["sessionID"]) 
    89         except Exception, error: 
    90             raise DXSessionObjectError, error 
    91  
    92         # Check status if already running 
     86        #try: 
     87        #    self.statusFile=os.path.join(RUNNING_DIR, self.bag["sessionID"]) 
     88        #except Exception, error: 
     89        #    raise DXSessionObjectError, error 
     90 
     91        # Get or make status 
    9392        if self.error==None: 
    94             try: 
    95                 if self.bag.has_key("action") and self.bag["action"]=="getStatus": 
    96                     self._getStatus() # sets value of self.status 
    97                     print "\n\nSTATUS:",self.status,"\n",self.statusFile 
    98             except: 
    99                 pass 
     93            if not self.bag.has_key("status"): 
     94                self.bag["status"]="constructing" 
     95            self.status=self.bag["status"] 
     96            #try: 
     97            #    if self.bag.has_key("action") and self.bag["action"]=="getStatus": 
     98            #        self._getStatus() # sets value of self.status 
     99            #        print "\n\nSTATUS:",self.status,"\n",self.statusFile 
     100            #except: 
     101            #    pass 
    100102 
    101103 
    102104        # Generate the options object 
    103         if self.error==None and not (self.bag.has_key("action") and self.bag["action"]=="getStatus"):    
     105        if self.error==None: # and not (self.bag.has_key("action") and self.bag["action"]=="getStatus"):         
    104106            try:    
    105107                self._generateOptions()   
     
    159161                      
    160162        # Process the selections to generate some data 
     163        #print "\n"*10, self.status, "GGGGGGGGG"*10 
    161164        if self.error==None:     
    162             if (self.bag.has_key("getOutput") and creditChecked==None) and self.options==[]: 
     165            if ((self.bag.has_key("getOutput") and creditChecked==None) and self.options==[]): 
    163166                # Check user has sufficient credit 
    164167                try:         
     
    168171                             
    169172                try:         
    170                     rtvalue=self._createOutput()  
    171                     if rtvalue==None: # Parent process 
    172                         self.bag["status"]="running" 
    173                         self.status=self.bag["status"]  
    174                     elif rtvalue==1: # Child process - request complete 
    175                         self.logger=LogManager(self.bag)             
    176                         self.bag["status"]="complete" 
    177                         self.status=self.bag["status"]   
     173                    #print "YYYYYYYYYYYYYYYYYYYYY"*40, self.status, "qqqqqqqqqqq"*20g 
     174                    if self.bag["estimatedDuration"]<10 and self.status=="constructing": 
     175                        self._updateStatus("running") 
     176                        self._saveSession() 
     177                        self._createOutput() 
     178                        self._updateStatus("complete") 
     179                        self.logger=LogManager(self.bag)             
     180                        self._updateStatus("complete") 
     181                        self.logger.logCompletedRequest(self.bag["outputFilePaths"])     
     182                    elif self.status=="queued": 
     183                        #print "HHHHHHHHHHHHH"*2000 
     184                        self._updateStatus("running") 
     185                        self._saveSession() 
     186                        self._createOutput() 
     187                        self._updateStatus("complete") 
     188                        self.logger=LogManager(self.bag)             
     189                        self._updateStatus("complete") 
    178190                        self.logger.logCompletedRequest(self.bag["outputFilePaths"])             
    179                         self.fork=1                  
    180                         # Mail user to say it completed... 
     191                        # Mail user to say it completed... 
    181192                        if RESTRICTED_DATA==1: 
    182                             self._sendCompletionMessage()                             
     193                            self._sendUserMessage("complete")    
     194                    elif self.status=="running": 
     195                        pass 
     196                    elif self.status=="complete": 
     197                        pass 
     198                    elif self.status=="constructing": 
     199                        self._updateStatus("queued") 
     200                        self._createOutput() 
     201                 
     202                    """rtvalue=self._createOutput()  
     203                    if rtvalue=="queued":  
     204                        self._updateStatus("queued") 
     205                        #self.status=self.bag["status"]  
     206                    elif rtvalue=="complete": """ 
     207                           
    183208 
    184209                except Exception, error: 
    185                     self.bag["status"]="failed" 
    186                     self.status=self.bag["status"] 
    187                     statusFile=open(self.statusFile, "a") 
    188                     errorString=str(error).replace("\n", "  ") 
    189                     if len(errorString)>0: 
    190                         sout="%s: ERROR_STRING %s." % (self.status, errorString) 
     210                    self.errorString=str(error).replace("\n", " ") 
     211                    self.status="failed" 
     212                    if len(self.errorString)>0: 
     213                        sout="%s: ERROR_STRING %s." % (self.status, self.errorString) 
    191214                    else: 
    192                         sout=self.status 
    193                     self.errorString=errorString 
    194                     statusFile.write(sout+"\n") 
    195                     statusFile.close() 
     215                        sout=self.status                     
     216                    self._updateStatus(sout) 
     217                    # Mail user to say it failed... 
     218                    if RESTRICTED_DATA==1: 
     219                        self._sendUserMessage("failed")   
    196220                    raise Exception, error 
    197221         
    198222        if self.error==None: 
    199             print "\nSaving session details:\n", self.bag, "\n\n"  
    200             if self.bag.has_key("action") and self.bag["action"]=="clearRequest": 
    201                 del self.bag["action"] 
    202             for key in ["proceed", "getOutput", "confirm", "action"]: 
    203                 if self.bag.has_key(key): 
    204                     del self.bag[key] 
    205             self.sessionObjectManager.writeSessionObject(self.bag) 
     223            self._saveSession() 
    206224        else: 
    207225            self.logger=LogManager(self.bag)  
    208226            self.logger.logError(self.error) 
    209227          
    210         if self.fork==1: pass # os._exit() 
     228        #if self.fork==1: pass # os._exit() 
    211229 
    212230             
     
    338356                                   "%.4d-%.2d-%.2dT%.2d:%.2d:%f" % tuple(value[1])) 
    339357 
    340     def _getStatus(self): 
    341         """ 
    342         Returns a status string for the job that is running (having forked). 
    343         """ 
    344         try: 
    345             line=open(self.statusFile).readlines()[-1] 
    346             self.status=line.strip() 
    347         except: 
    348             self.status="No status information available about your request." 
    349  
    350         if self.status.find("ERROR_STRING")>-1: 
    351             self.errorString=self.status.split("ERROR_STRING")[-1] 
    352             self.status="failed" 
    353         self.bag["status"]=self.status 
     358    #def _getStatus(self): 
     359    #    """ 
     360    #    Returns a status string for the job that is running (having forked). 
     361    #    """ 
     362    #    try: 
     363    #        line=open(self.statusFile).readlines()[-1] 
     364    #        self.status=line.strip() 
     365    #    except: 
     366#           self._updateStatus("constructing") 
     367#            #elf.status="No status information available about your request." 
     368# 
     369#        if self.status.find("ERROR_STRING")>-1: 
     370#            self.errorString=self.status.split("ERROR_STRING")[-1] 
     371#            self.status="failed" 
     372#        self.bag["status"]=self.status 
     373         
     374         
     375    def _updateStatus(self, status="constructing"): 
     376        """ 
     377        Updates self.status, self.bag["status"] and status file. 
     378        """ 
     379        self.bag["status"]=status 
     380        self.status=self.bag["status"] 
    354381 
    355382 
     
    392419            return (duration, outputSize) 
    393420         
    394         print "\n"*5 
    395         print os.getpid(),"\n\n" 
    396         print """FORKING HERE...""" 
    397  
    398         if duration<0: 
    399             # No need to fork quick process 
    400             outputManager.createOutputs() 
    401         else: 
    402             forkedProcess=os.fork() 
    403  
    404             if forkedProcess==0: 
    405                 self.bag["status"]="processing" 
    406                 self.status=self.bag["status"] 
    407                 statusFile=open(self.statusFile, "a") 
    408                 statusFile.write(self.status+"\n") 
    409                 statusFile.close() 
     421        #print "\n"*5 
     422        #print os.getpid(),"\n\n" 
     423        print """Either run right away or queue with command-line if takes a long time....""" 
     424 
     425        #if self.status=="undefined": raise DXError, "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL" 
     426        if duration<10: # seconds 
     427                print "\nRunning without QUEUE because so small!\n" 
     428                outputManager.createOutputs() 
     429                print "Ran without queuing and status:", self.status, "\n\n" 
     430        if self.status=="running": 
    410431                outputManager.createOutputs() 
    411                 self.bag["status"]="complete" 
    412                 self.status=self.bag["status"] 
    413                 statusFile=open(self.statusFile, "a") 
    414                 statusFile.write(self.status+"\n") 
    415                 statusFile.close() 
    416  
    417                 return 1 
     432                print "Ran and status:", self.status 
     433        elif self.status=="queued": 
     434                print """Launching local version... note that python and script location needs setting up an install time.""" 
     435                cmd="""export PYTHONPATH=$PYTHONPATH:/usr/local/test/dxs/configs:/usr/local/test/dxs ; /usr/local/cdat/bin/python /usr/local/test/dxs/scripts/runExtraction.py -s %s &""" % self.bag["sessionID"] 
     436                #print "NOTICE ME:!!!!:"*20,"\n", self.status 
     437                print "\nSubmitting:", cmd 
     438                os.system(cmd) 
     439                # self._updateStatus("complete") 
     440 
     441 
     442    def _saveSession(self): 
     443        """ 
     444        Saves the contents of the current session (self.bag).  
     445        """ 
     446        print "\nSaving session details:\n", self.bag, "\n\n"  
     447        if self.bag.has_key("action") and self.bag["action"]=="clearRequest": 
     448            del self.bag["action"] 
     449        for key in ["proceed", "getOutput", "confirm", "action"]: 
     450            if self.bag.has_key(key): 
     451                del self.bag[key] 
     452        self.sessionObjectManager.writeSessionObject(self.bag) 
     453         
     454 
     455    def _sendUserMessage(self, outcome): 
     456        """ 
     457        Mails user to inform her that job has completed and where files are. 
     458        """ 
     459        subject="BADC Data Extractor: Job %s %s" % (self.bag["sessionID"], outcome) 
     460         
     461        if outcome=="complete": 
     462            fileList=[translateURI(uri) for uri in self.bag["outputFilePaths"]] 
     463            pathString="" 
     464            length=len(fileList) 
     465            if length==1: 
     466                plural1="file has" 
     467                plural2="is" 
    418468            else: 
    419                 return 
    420  
    421     def _sendCompletionMessage(self): 
    422         """ 
    423         Mails user to inform her that job has completed and where files are. 
    424         """ 
    425         subject="BADC Data Extractor: Job %s complete" % self.bag["sessionID"] 
    426         fileList=[translateURI(uri) for uri in self.bag["outputFilePaths"]] 
    427         pathString="" 
    428         length=len(fileList) 
    429         if length==1: 
    430             plural1="file has" 
    431             plural2="is" 
    432         else: 
    433             plural1="files have" 
    434             plural2="are" 
    435  
    436         if length>50: 
    437             lm50=length-50 
    438             midString=""" 
     469                plural1="files have" 
     470                plural2="are" 
     471 
     472            if length>50: 
     473                lm50=length-50 
     474                midString=""" 
    439475   *** and %s more files following the same file-naming convention... *** 
    440476""" % lm50 
    441             fileList=fileList[:25]+[midString]+fileList[-25:] 
    442         for f in fileList: 
    443             pathString+="""%s 
     477                fileList=fileList[:25]+[midString]+fileList[-25:] 
     478            for f in fileList: 
     479                pathString+="""%s 
    444480""" % f 
    445481          
    446         msg="""Dear BADC User, 
    447  
    448 Your Data Extractor job has successfully completed. 
     482            msg="""Dear BADC User, 
     483 
     484Your Data Extractor job (id=%s) has successfully completed. 
    449485 
    450486%s output %s been produced and %s accessible via: 
     
    458494If you have any comments please contact the Administrator at: %s 
    459495 
    460 """ % (length, plural1, plural2, pathString, ADMIN_MAIL_ADDRESS) 
    461         sendMail([self.userEmail], subject, msg, autoline="off") 
    462  
     496""" % (self.bag["sessionID"], length, plural1, plural2, pathString, ADMIN_MAIL_ADDRESS) 
     497            sendMail([self.userEmail], subject, msg, autoline="off") 
     498             
     499        elif outcome=="failed": 
     500            msg="""Dear BADC User, 
     501 
     502Your Data Extractor job (id=%s) has failed. We apologise for this inconvenience. 
     503 
     504The administrator has been informed of the error (%s). 
     505 
     506""" % (self.bag["sessionID"], ADMIN_MAIL_ADDRESS) 
     507            sendMail([ADMIN_MAIL_ADDRESS, self.userEmail], subject, msg, autoline="off") 
    463508 
    464509 
  • TI03-DataExtractor/trunk/pydxs/FileNames.py

    r1715 r2009  
    1313 
    1414# Import standard library modules  
    15 import os, sys  
     15import os, sys, time 
    1616 
    1717# Import package modules  
     
    5353            self.template=self.template[:-1] 
    5454             
     55        uniquishString=self._getUniquishNamePart()     
     56         
    5557        if self.fileFormat:  
    56             self.template=self.template+"."+mapFileFormatToExtension(self.fileFormat) 
     58            self.template=self.template+"_"+uniquishString+"."+mapFileFormatToExtension(self.fileFormat) 
    5759        self.template=self._tidyFileNameObject(self.template)     
    5860         
    5961        if self.template=="dx_output_<date_time_here>":   # If no information given use process ID for numbering  
    6062            self.pid=os.getpid()                         
    61             self.template="dx_output_"+str(self.pid)  
     63            self.template="dx_output_"+str(self.pid)+"_"+uniquishString 
    6264  
    6365        if basedir: 
     
    214216        return fnobj 
    215217         
     218    def _getUniquishNamePart(self): 
     219        """ 
     220        Returns a string derived from the time of day that should stop the same 
     221        filename being written twice except in very unlikely conditions. 
     222        """ 
     223        t=time.time() 
     224        rt=str(int(t)).split(".")[0][-6:] 
     225        return rt 
     226     
    216227         
    217228if __name__=="__main__": 
     
    221232    print x.createFileNameList() 
    222233    print x.getFileNameTemplate() 
     234     
     235    x=FileNames()#datasetGroup="Test Data Group 1", dataset="Test Dataset 1", timeSteps=None,  
     236                #horizontalBounds=[45,360], verticalDomain=[1000,850,500], variables=["temp"],  
     237                #fileFormat="NetCDF") 
     238    print x.createFileNameList() 
     239    print x.getFileNameTemplate() 
     240     
     241    x=FileNames(datasetGroup="Test Data Group 1", dataset="Test Dataset 1",  
     242                timeSteps=("1999-01-01T00:00:00", "2004-05-06T23:00:00"), 
     243                horizontalBounds=[45,360], verticalDomain=[1000,850,500], variables=["temp"],  
     244                fileFormat="NetCDF") 
     245    print x.createFileNameList() 
     246    print x.getFileNameTemplate()     
  • TI03-DataExtractor/trunk/pydxs/MIDASDataHandler.py

    r1780 r2009  
    121121        countyList=areas # midasMetadataHandler.getCounties() 
    122122        counties=["county","county","Counties","N/A","full list","Note that selection of items in this category will override the lat/lon selection"]+countyList 
    123         src_ids=["src_id","src_id","Station src_id(s)","N/A","comma-separated integer1-5",  
    124                  """Note that selection of items in this category will override lat/lon and county/country selections. 
    125  You can view the src_id list at: <a href="http://badc.nerc.ac.uk/data/ukmo-midas/Docs/src_id_list.xls"> 
    126 http://badc.nerc.ac.uk/data/ukmo-midas/Docs/src_id_list.xls</a>. """,0,0,0] 
     123        src_ids=["src_id","src_id","WMO Station Numbers","N/A","comma-separated integer1-5","Note that selection of items in this category will override lat/lon and county/country selections",0,0,0] 
    127124 
    128125        countries=["..."] 
  • TI03-DataExtractor/trunk/setup.py

    r1715 r2009  
    308308    if "dxs" in packages: 
    309309        print """You can start the server Web Service by typing: 
    310     python %s/bin/DXWSInterface.py %s/configs/serverConfig.py 
     310    python %s/scripts/DXWSInterface.py %s/configs/serverConfig.py 
    311311    """ % (dxsBasedir, dxsBasedir) 
    312312 
Note: See TracChangeset for help on using the changeset viewer.