source: TI03-DataExtractor/trunk/cgi/dxui @ 1715

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI03-DataExtractor/trunk/cgi/dxui@1715
Revision 1715, 25.1 KB checked in by astephen, 13 years ago (diff)

Merged with titania version.

  • Property svn:executable set to *
Line 
1#!<YOUR_PYTHON_HERE>
2#   Copyright (C) 2004 CCLRC & NERC( Natural Environment Research Council ).
3#   This software may be distributed under the terms of the
4#   Q Public License, version 1.0 or later. http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt
5
6"""
7dxui
8====
9
10Holds the CGIClient class the users interact with if they
11are calling the DX web service via a CGI interface through a
12web browser. Typically this script will be called "dxui".
13
14"""
15
16# Import standard library modules
17import cgi, random, time, re, os, sys
18
19# Import SOAP library
20from ZSI.client import Binding
21from ZSI.version import Version as zsiv
22zsiv=float("%s.%s" % zsiv[:2])
23       
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         
30# Import package modules
31from pydxc import *
32
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
43# Set up CGI error reporting if DEBUG is set to 1 in clientConfig.py module
44#DEBUG=1
45if DEBUG==1:
46    import cgitb
47    cgitb.enable()
48
49
50class DXCGIClient:
51    """
52    The controlling class for interacting with the dx via the web.
53    """
54   
55    def __init__(self):
56        """
57        Initiates the instance setting up the appropriate
58        internal objects and calls to the relevant classes depending
59        on the configuration and arguments provided.
60        """
61        self.username="undefined"
62        self.password="undefined"
63        self.secureToken="undefined"
64        self.userRoles=[]
65        self.loginStatus="out"
66        self.loginMessage=""
67        self.sessionObject={}
68       
69        self.displayer=DisplayManager()
70
71        #self.displayer._displayHTTPHeader()
72
73        # Parse the arguments
74        try:
75            self._parseArgs()
76        except:
77            if DEBUG==1:
78                raise
79            else:
80                CGIErrorHandler("Error parsing arguments: "+str(sys.exc_type), noheader=0)
81
82        # Destroy any arguments not intended to pass any further
83        try:
84            self._destroyUnnecessaryArgs()
85        except:
86            if DEBUG==1:
87                raise
88            else:
89                CGIErrorHandler("Error destroying arguments: "+str(sys.exc_type), noheader=0)
90
91        # If switched on check security       
92        if RESTRICTED_DATA==1:
93            try:
94                self._checkSecurity()
95            except:
96                if DEBUG==1:
97                    raise
98                else:
99                    CGIErrorHandler("Security error: "+str(sys.exc_type), noheader=0)
100        else:
101            self.secureToken="undefined"
102
103        #print "Content-type: text/html\n\n"
104           
105        # Call the dx Web Service with the arguments provided       
106        try:
107            self._callDXWebService(self.args)   
108        except SystemExit:
109            pass         
110        except:
111            if DEBUG==1:
112                raise
113            else:
114                CGIErrorHandler("Error calling dx Web Service: "+str(sys.exc_type), noheader=0)       
115
116        try:   
117            self.displayer._displayHTMLFooter()
118        except:
119            if DEBUG==1:
120                raise
121            else:
122                CGIErrorHandler("Error generating HTML footer: "+str(sys.exc_type), noheader=0)
123       
124       
125    def _parseArgs(self):
126        """
127        Parses the arguments sent, if any, ready for sending to the
128        web service.
129        """
130        # Get arguments
131        self.args={}                           
132        args=cgi.FieldStorage()
133        self.fieldStorage=args
134       
135        # Get upload file link
136        if args.has_key("uploadedFile"):
137            self.tempFileLink=args["uploadedFile"].file
138            self.args["fileName"]=args["uploadedFile"].filename
139
140        # Populate the argument dictionary
141        for key in args.keys():
142            if key=="uploadedFile": continue
143            self.args[key]=args.getvalue(key)
144                   
145        if self.args.has_key("sessionID") and self.args["sessionID"]=="undefined":
146            self.args["sessionID"]="undefined"     
147         
148        # Check for secure items, destroy if necessary and assign as instance variables   
149        if self.args.has_key("yousirnaim"):
150            self.username=self.args["yousirnaim"]
151            self.args["username"]=self.username
152            del self.args["yousirnaim"]
153           
154        if self.args.has_key("parcewerd"):
155            self.password=self.args["parcewerd"]
156            del self.args["parcewerd"] 
157               
158        if self.args.has_key("secureToken"):
159            self.secureToken=self.args["secureToken"]
160            del self.args["secureToken"]   
161       
162        if not self.args.has_key("username"):
163            self.args["username"]="undefined"
164           
165        #self._determineNumberOfDatasets()
166        #self._parsePartialDimensionArgs()
167       
168        self._compileAxisSelections()
169       
170
171    def _compileAxisSelections(self):
172        """
173        Compiles partial selections from the last form selections
174        so that axis start and end components are linked into a
175        list of arguments and string components become whole date/time
176        strings.
177        """
178        #print "Content-Type: text/html\n\n"
179        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()])     
180        dateTimeTemplate="%.4d-%.2d-%.2dT%.2d:%.2d:%f"
181        timeAxisItems=getDictSubsetMatching(self.args, "axis_.*_low\.time\.year", "regex")
182       
183        # Must have come from dxui so if year is there all others will be
184        for name, value in timeAxisItems.items():
185            axisIndex=re.match(r"axis_(.*)_low\.time\.year", name).groups()[0]
186            tcList=[]
187            for lh in ("low", "high"):
188                for t in "year month day hour minute second".split():
189                    argName="axis_%s_%s.time.%s" % (axisIndex, lh, t)
190                    tcList.append(self.args[argName])
191                    del self.args[argName]
192       
193            # Now compile into start and end date time
194            floatList=[float(i) for i in tcList]
195            self.args["axis_%s" % axisIndex]=[dateTimeTemplate % tuple(floatList[:6]),
196                                              dateTimeTemplate % tuple(floatList[6:])]
197
198        otherAxisItems=getDictSubsetMatching(self.args, "axis_.*_low$", "regex")
199        for name, value in otherAxisItems.items():
200            axisIndex=re.match(r"axis_(.*)_low$", name).groups()[0]
201            iList=[]
202            for lh in ("low", "high"):
203                argName="axis_%s_%s" % (axisIndex, lh)
204                iList.append(self.args[argName])
205                del self.args[argName]
206       
207            try:
208                if zsiv>=2.0:
209                    iList=[float(i) for i in iList]
210                else:
211                    iList=[int(i) for i in iList]
212            except:
213                try:
214                    iList=[int(i) for i in iList]
215                except:
216                    pass
217           
218            self.args["axis_%s" % axisIndex]=iList
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
286        #print "Content-Type: text/html\n\n"
287        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()])
288       
289
290    def _destroyUnnecessaryArgs(self):
291        """
292        Destroy the arguments that should not be passed to the main dx Web Service.
293        """
294        if self.args.has_key("password"):
295            del self.args["password"]   
296       
297       
298    def _checkSecurity(self):
299        """
300        If security is switched on with RESTRICTED_DATA=1 then this will
301        call the local implementation of the security.
302        """
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])
310       
311            # Deal with logout
312            ############# NOTE - doesn't destroy session server side (yet)
313            if self.args.has_key("logout") and self.args["logout"]=="Logout":
314                secChecker.logout()
315                secCheck="You have been logged out."
316                self.username="undefined"
317                self.loginStatus="out"
318            else:
319                secCheck=secChecker.validate()     
320           
321            if type(secCheck)==type(""):
322                # Returned string means error in log in or logged out
323                self.loginMessage=secCheck
324            else:
325                self.loginStatus="in"
326                self.loginMessage=""
327
328                (self.secureToken, self.username, self.userRoles)=secCheck
329               
330        elif SECURITY_MODEL=="ndg":
331            from pydxc.NDGSecurityViaCGI import *
332            secChecker=NDGSecurityViaCGI(cookie=self.secureToken, urlArgs=self.fieldStorage)
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()
345           
346            # Delete field storage so not visible anywhere
347            #del self.fieldStorage
348
349               
350    def _callDXWebService(self, args):
351        """
352        According to the arguments given this binds to an appropriate
353        Web Service and calls it with the relevant arguments.
354        """
355        #print "Content-Type: text/html\n\n" ; print self.userRoles
356        # Just print the login page if not logged in and login required
357        if RESTRICTED_DATA==1 and self.loginStatus=="out":
358            self.displayer._displayHTTPHeader()
359            self.displayer._displayHTMLHeader()
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
378            return     
379                             
380        # Set up SOAP bindings 
381        if CALL_METHOD.upper()=="WS":
382            self.server=WSCaller()
383        elif CALL_METHOD.upper()=="LOCAL":
384            serverLocation=LOCAL_SERVER_PACKAGE
385            sys.path.append(serverLocation)
386            print sys.path
387            self.server=LocalCaller()
388
389        # Get session ID
390        self._getSession()
391       
392        # Check if complete
393        isCompleteStatus=self._checkIfComplete()
394       
395
396        # Perform actions as requested by user
397        if self.args.has_key("action"):
398            actionReturn=self._performActions()
399            if actionReturn=="Display footer then complete":
400                return
401       
402        # Clear request if required
403        if self.args.has_key("clearRequest") or self.args.has_key("newRequest"):
404            if self.args.has_key("clearRequest"):
405                del self.args["clearRequest"]
406            else:
407                del self.args["newRequest"] 
408            self.sessionID, self.secureToken=self.server.callServerMethod("newRequest",
409                                                  [self.sessionID, self.secureToken])                                           
410
411        # Make sure instance and args sessionID are the same
412        self.args["sessionID"]=self.sessionID
413       
414        # Ensure args contains secureToken object
415        if not self.args.has_key("secureToken"):
416            self.args["secureToken"]=self.secureToken
417
418        # Get the options (and make selections if appropriate)
419        (optionCategories, options, optionStrings, summaryString, secureToken)=self._getLatestOptions()
420       
421        # Get summary of request and determine number of datasets   
422        #self.summary=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0]
423           
424        # Analyse the request
425        self._respondToOptionCategories(optionCategories, options, optionStrings, summaryString)       
426   
427       
428    def _getSession(self):
429        """
430        Checks if a session is already underway and starts one if not.
431        """           
432        # If no session then start a session and get a sessionID
433        if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None", "undefined"):
434            # Start session if not known about
435            #print "Content-type: text/html\n\n", self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])
436            if zsiv>=2.0:
437                self.sessionID, self.secureToken=self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])[0]
438            else:
439                self.sessionID, self.secureToken=self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])
440        else:
441            self.sessionID=self.args["sessionID"]
442           
443           
444    def _checkIfComplete(self):
445        """
446        Checks if complete, returns 1 (yes) or 0 (no).
447        """
448        isCompleteStatus=0       
449        if self.args.has_key("isComplete"):     
450            isCompleteStatus, self.secureToken=self.server.callServerMethod("isComplete",
451                                                      [self.sessionID, self.secureToken])     
452        return isCompleteStatus
453       
454       
455    def _performActions(self):
456        """
457        If "action" argument received then do the appropriate action.
458        """     
459        if 1:  # Move all back <-- one tab and delete this line
460            action=self.args["action"]
461            if action=="viewRequestSummary":
462                summaryString=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0]
463                if zsiv>=2.0:
464                    summaryString=summaryString[0][0]
465
466                self.displayer._displayHTMLHeader()
467                if RESTRICTED_DATA==1:
468                    roleString=",".join(self.userRoles)
469                    self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+roleString)
470                self.displayer._displayRequestSummaryTable(createSummaryDict(summaryString))
471                self.displayer._displayReturnLine(self.sessionID)
472                return "Display footer then complete"
473
474            elif action=="saveRequest":
475                x=self.server.callServerMethod("getDataSubsetSpecifier",
476                                                           [self.sessionID, self.secureToken])
477
478                #dataSubsetSpecifier, self.secureToken=x                                           
479                self.displayer._displayHTTPHeader()
480                self.displayer._displayHTMLHeader()     
481                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))       
482                self.displayer._displaySaveRequestOptions(dataSubsetSpecifier, self.sessionID)
483                self.displayer._displayReturnLine(self.sessionID)
484                return "Display footer then complete"
485               
486            elif action=="uploadRequest":
487                self.displayer._displayHTTPHeader()
488                self.displayer._displayHTMLHeader()
489                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
490                self.displayer._displayUploadRequestOptions(self.sessionID)
491                self.displayer._displayReturnLine(self.sessionID)               
492                return "Display footer then complete"           
493               
494            elif action=="parseUploadedFile":
495                xmlFileString=self.tempFileLink.read()
496                status, self.secureToken=self.server.callServerMethod("uploadRequest",
497                                              [self.sessionID, xmlFileString, self.secureToken])
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
519         
520    def _getLatestOptions(self):
521        """
522        If target page provided then get the options for that page,
523        otherwise get whatever options are presented by the dx and
524        send latest selections to update request.
525        """
526        if self.args.has_key("targetPage"):
527            tp=self.args["targetPage"]
528            tp2catMap={"DatasetGroupPage":"datasetGroup", "DatasetPage":"dataset",
529                       "VariablesPage":"variable", "DomainAndFormatPage":"domainAndFormat"}
530            optionCategory=tp2catMap[tp]
531            self.args["optionCategoryRequested"]=optionCategory
532            # Need to delete targetPage otherwise it will stay forever
533            del self.args["targetPage"]
534
535        response=self.server.callServerMethod("selectOptions", [self.sessionID, self._packArgsAsList(self.args)])
536        #self.displayer._displayHTTPHeader()
537        #print response, type(response)
538        (optionCategories, options, optionStrings, summaryString, secureToken)=self._translateResponse(response)       
539        #print (optionCategories, options, optionStrings, summaryString, secureToken)   
540        return (optionCategories, options, optionStrings, summaryString, secureToken)
541
542   
543    def _translateResponse(self, response):
544        """
545        Takes an object received from the WS and translates to:
546        (optionCategories, options, optionStrings, secureToken)
547        """
548        response=response[0]       
549        if zsiv>=2.0:
550            response=response[0][0]
551        optionCategories=[item[0] for item in response[:-2]]
552        options=[item[1] for item in response[:-2]]
553        optionStrings=options
554        summaryString=response[-2]
555        secureToken=response[-1]               
556        return (optionCategories, options, optionStrings, summaryString, secureToken)
557       
558
559    def _respondToOptionCategories(self, optionCategories, options, optionStrings, summaryString):
560        """
561        Work out what the option category is and respond by displaying
562        the appropriate user interface.
563        """     
564        summaryDict=createSummaryDict(summaryString)
565        # Analyse the option categories now
566        if optionCategories=="No category" or optionCategories==[]:
567            optcat=None
568        else:
569            optcat=optionCategories[0].split("_")[0]
570       
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       
576        # Can display simple form for these categories 
577        elif optcat in ("datasetGroup", "dataset", "variable"):         
578            self.displayer._displayHTTPHeader()
579            self.displayer._displayHTMLHeader()     
580            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
581            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID)
582            self.displayer._displayMainTableHeader(self.sessionID)
583            self.displayer._displayOptionsTable(summaryDict, optionCategories, options, optionStrings, self.sessionID, self.sessionObject)
584            self.displayer._displayMainTableFooter()
585       
586        # Need to make a number of web service calls to get information
587        # for each domain as well as output format which are all
588        # displayed on the same page.   
589        elif optcat=="axis":
590            self.displayer._displayHTTPHeader()
591            self.displayer._displayHTMLHeader()
592            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
593            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID)
594            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections("off")'""")
595            self.displayer._displayDomainOptions(summaryDict, optionCategories, options, optionStrings, self.sessionID)
596            self.displayer._displayMainTableFooter()
597               
598        elif optcat==None:
599            # If there are no option categories then the request is likely to be complete
600            # Display confirmation page if needed
601            if CONFIRMATION_PAGE==1 and not self.args.has_key("confirm"):
602                self.displayer._displayHTTPHeader()
603                self.displayer._displayHTMLHeader()
604                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
605                self.displayer._displayDatasetSummaryLine(summaryString, optionCategories, self.sessionID)         
606                self.displayer._displayMainTableHeader(self.sessionID)   
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">'
616                self.displayer._displayConfirmationSection(summaryDict)
617               
618            # Or display final job processing page     
619            elif self.args.has_key("action") and self.args["action"]=="requestCosts":   
620                response=self.server.callServerMethod("getExtractionCosts",
621                                                          [self.sessionID, self.secureToken])  #[0][0:2]
622                if zsiv>=2.0:
623                    response=response[0]
624
625                (estimatedDuration, estimatedVolume)=response[0:2]
626                self.displayer._displayHTTPHeader()
627                self.displayer._displayHTMLHeader()
628                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
629                self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID)
630                response=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])  #[0]
631               
632                if zsiv>=2.0:
633                    response=response[0]
634                pathList, self.secureToken=response
635                #print "<P>", pathList, len(pathList)
636                self.displayer._displayOutputFileList(pathList)
637
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
654
655    def _packArgsAsList(self, args):
656        """
657        In order to work with ZSI SOAP library need to pack up arguments as a list
658        of [keyword, value] pairs rather than a dictionary.
659        """
660        newList=[]
661        for key, value in args.items():
662            newList.append([key, value])
663        return newList
664       
665
666if __name__=="__main__":
667
668    DXCGIClient()       
Note: See TracBrowser for help on using the repository browser.