source: TI03-DataExtractor/branches/titania_install/cgi/dxui.py @ 1610

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI03-DataExtractor/branches/titania_install/cgi/dxui.py@1610
Revision 1610, 25.0 KB checked in by astephen, 14 years ago (diff)

Latest live version on titania.

  • Property svn:executable set to *
Line 
1#!/usr/local/badc/linux/suse10/cdat/bin/python
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="/usr/local/badc/linux/suse10/dxc/configs/clientConfig.py"
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# Import BADC security
34sys.path.append("/home/badc/software/pythonlib/badc")
35from BADCSecurityViaCGI import *
36
37# Set up CGI error reporting if DEBUG is set to 1 in clientConfig.py module
38#DEBUG=1
39if DEBUG==1:
40    import cgitb 
41    cgitb.enable() 
42
43
44class DXCGIClient:
45    """
46    The controlling class for interacting with the dx via the web.
47    """
48   
49    def __init__(self):
50        """
51        Initiates the instance setting up the appropriate
52        internal objects and calls to the relevant classes depending
53        on the configuration and arguments provided.
54        """
55        self.username="undefined"
56        self.password="undefined"
57        self.secureToken="undefined"
58        self.userRoles=[]
59        self.loginStatus="out"
60        self.loginMessage=""
61        self.sessionObject={}
62       
63        self.displayer=DisplayManager()
64
65        #self.displayer._displayHTTPHeader()
66
67        # Parse the arguments
68        try:
69            self._parseArgs()
70        except:
71            if DEBUG==1:
72                raise
73            else:
74                CGIErrorHandler("Error parsing arguments: "+str(sys.exc_type), noheader=0)
75
76        # Destroy any arguments not intended to pass any further
77        try:
78            self._destroyUnnecessaryArgs()
79        except:
80            if DEBUG==1:
81                raise
82            else:
83                CGIErrorHandler("Error destroying arguments: "+str(sys.exc_type), noheader=0)
84
85        # If switched on check security       
86        if RESTRICTED_DATA==1:
87            try:
88                self._checkSecurity()
89            except:
90                if DEBUG==1:
91                    raise
92                else:
93                    CGIErrorHandler("Security error: "+str(sys.exc_type), noheader=0)
94        else:
95            self.secureToken="undefined"
96
97        #print "Content-type: text/html\n\n"
98           
99        # Call the dx Web Service with the arguments provided       
100        try:
101            self._callDXWebService(self.args)   
102        except SystemExit:
103            pass         
104        except:
105            if DEBUG==1:
106                raise
107            else:
108                CGIErrorHandler("Error calling dx Web Service: "+str(sys.exc_type), noheader=0)       
109
110        try:   
111            self.displayer._displayHTMLFooter() 
112        except:
113            if DEBUG==1:
114                raise
115            else:
116                CGIErrorHandler("Error generating HTML footer: "+str(sys.exc_type), noheader=0)
117       
118       
119    def _parseArgs(self):
120        """
121        Parses the arguments sent, if any, ready for sending to the
122        web service.
123        """
124        # Get arguments
125        self.args={}                           
126        args=cgi.FieldStorage() 
127        self.fieldStorage=args
128       
129        # Get upload file link
130        if args.has_key("uploadedFile"):
131            self.tempFileLink=args["uploadedFile"].file
132            self.args["fileName"]=args["uploadedFile"].filename
133
134        # Populate the argument dictionary
135        for key in args.keys(): 
136            if key=="uploadedFile": continue
137            self.args[key]=args.getvalue(key) 
138                   
139        if self.args.has_key("sessionID") and self.args["sessionID"]=="undefined":
140            self.args["sessionID"]="undefined"     
141         
142        # Check for secure items, destroy if necessary and assign as instance variables   
143        if self.args.has_key("yousirnaim"):
144            self.username=self.args["yousirnaim"]
145            self.args["username"]=self.username
146            del self.args["yousirnaim"]
147           
148        if self.args.has_key("parcewerd"):
149            self.password=self.args["parcewerd"] 
150            del self.args["parcewerd"] 
151               
152        if self.args.has_key("secureToken"):
153            self.secureToken=self.args["secureToken"]
154            del self.args["secureToken"]   
155       
156        if not self.args.has_key("username"):
157            self.args["username"]="undefined"
158           
159        #self._determineNumberOfDatasets()
160        #self._parsePartialDimensionArgs()
161       
162        self._compileAxisSelections()
163       
164
165    def _compileAxisSelections(self):
166        """
167        Compiles partial selections from the last form selections
168        so that axis start and end components are linked into a
169        list of arguments and string components become whole date/time
170        strings.
171        """
172        #print "Content-Type: text/html\n\n"
173        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()])     
174        dateTimeTemplate="%.4d-%.2d-%.2dT%.2d:%.2d:%f"
175        timeAxisItems=getDictSubsetMatching(self.args, "axis_.*_low\.time\.year", "regex")
176       
177        # Must have come from dxui so if year is there all others will be
178        for name, value in timeAxisItems.items():
179            axisIndex=re.match(r"axis_(.*)_low\.time\.year", name).groups()[0]
180            tcList=[]
181            for lh in ("low", "high"):
182                for t in "year month day hour minute second".split():
183                    argName="axis_%s_%s.time.%s" % (axisIndex, lh, t)
184                    tcList.append(self.args[argName])
185                    del self.args[argName]
186       
187            # Now compile into start and end date time
188            floatList=[float(i) for i in tcList]
189            self.args["axis_%s" % axisIndex]=[dateTimeTemplate % tuple(floatList[:6]),
190                                              dateTimeTemplate % tuple(floatList[6:])]
191
192        otherAxisItems=getDictSubsetMatching(self.args, "axis_.*_low$", "regex")
193        for name, value in otherAxisItems.items():
194            axisIndex=re.match(r"axis_(.*)_low$", name).groups()[0]
195            iList=[]
196            for lh in ("low", "high"):
197                argName="axis_%s_%s" % (axisIndex, lh)
198                iList.append(self.args[argName])
199                del self.args[argName]
200       
201            try:
202                if zsiv>=2.0:
203                    iList=[float(i) for i in iList]
204                else:
205                    iList=[int(i) for i in iList]
206            except:
207                try:
208                    iList=[int(i) for i in iList]
209                except:
210                    pass
211           
212            self.args["axis_%s" % axisIndex]=iList
213
214        # Now cope with axes with only one value selected - we need a list
215        # Also deal with a list of strings that should be floats
216     
217        for arg,value in self.args.items():
218            try:
219                if value.find("[OPTIONAL]")>-1:
220                    del self.args[arg]
221                    continue
222            except:
223                pass
224
225            if arg[:4]=="axis":
226                if type(value) not in (type((1,2)), type([2,3])):
227                    try: 
228                        if value.find(",")>-1:
229                            value=[i.strip() for i in value.split(",")]
230                            try:
231                                value=[float(i) for i in value]
232                            except:
233                                pass
234                            self.args[arg]=value
235                        else:
236                            raise "something"
237                    except:
238                        try:
239                            value=float(value)
240                        except:
241                            try:
242                                value=int(value)
243                            except:
244                                pass
245                        self.args[arg]=[value,value]
246                else:
247                    value=[i for i in value]
248                    try:
249                        value=[float(i) for i in value]
250                    except:
251                        pass
252                    self.args[arg]=value
253   
254        # Quick fix for long list of floats where we want just the two extremes:
255        for arg,value in self.args.items():
256            if type(value[0])==type(2.3) and len(value)>2:
257                value=[value[0], value[-1]]
258                self.args[arg]=value
259
260        # Finally, identify args coming in as "clonedomain_w.x.y.z" and clone axes
261        # for these.
262       
263        cloneDomains=getDictSubsetMatching(self.args, "clonedomain", "regex")
264
265        for arg,value in cloneDomains.items():
266            varIndex=arg.split("_")[-1]
267            axesToClone=getDictSubsetMatching(self.args, "axis_%s" % value, "regex")
268            for axkey,axvalue in axesToClone.items():
269                axisIndex=axkey.split(".")[-1]
270                newKey="axis_%s.%s" % (varIndex, axisIndex)
271                self.args[newKey]=axvalue
272
273            outputFormatToClone=getDictSubsetMatching(self.args, "outputFormat", "regex")
274            ofkey,ofvalue=outputFormatToClone.items()[0]
275            newKey="outputFormat_%s" % varIndex
276            self.args[newKey]=ofvalue
277            # Delete this clonedomain item
278            del self.args[arg]
279
280        #print "Content-Type: text/html\n\n"
281        #print "<P>".join(["%s:%s" % (n,v) for (n,v) in self.args.items()])
282       
283
284    def _destroyUnnecessaryArgs(self):
285        """
286        Destroy the arguments that should not be passed to the main dx Web Service.
287        """
288        if self.args.has_key("password"):
289            del self.args["password"]   
290       
291       
292    def _checkSecurity(self):
293        """
294        If security is switched on with RESTRICTED_DATA=1 then this will
295        call the local implementation of the security.
296        """
297        if SECURITY_MODEL=="basic" or SECURITY_MODEL=="badc":
298            if SECURITY_MODEL=="basic":
299                secClass=SecurityViaCGI
300            elif SECURITY_MODEL=="badc":
301                secClass=BADCSecurityViaCGI
302
303            secChecker=apply(secClass, [self.username, self.password, self.secureToken])
304       
305            # Deal with logout
306            ############# NOTE - doesn't destroy session server side (yet)
307            if self.args.has_key("logout") and self.args["logout"]=="Logout":
308                secChecker.logout()
309                secCheck="You have been logged out."
310                self.username="undefined"
311                self.loginStatus="out"
312            else:
313                secCheck=secChecker.validate()     
314           
315            if type(secCheck)==type(""):
316                # Returned string means error in log in or logged out
317                self.loginMessage=secCheck
318            else:
319                self.loginStatus="in"
320                self.loginMessage=""
321
322                (self.secureToken, self.username, self.userRoles)=secCheck
323               
324        elif SECURITY_MODEL=="ndg":
325            from pydxc.NDGSecurityViaCGI import *
326            secChecker=NDGSecurityViaCGI(cookie=self.secureToken, urlArgs=self.fieldStorage)
327            self.loginlist=secChecker.getTrustedHostList()
328           
329            #(self.secureToken, self.username, self.userRoles)=
330            secCheck=secChecker.validate()
331            if type(secCheck)==type(""):
332                self.loginMessage=secCheck
333            else:
334                self.loginStatus="in"
335                self.loginMessage=""
336                (self.secureToken, self.username, self.userRoles)=secCheck
337
338            #o=open("/tmp/t", "w"); o.write("%s" % repr(secCheck)); o.close()
339           
340            # Delete field storage so not visible anywhere
341            #del self.fieldStorage
342
343               
344    def _callDXWebService(self, args):
345        """
346        According to the arguments given this binds to an appropriate
347        Web Service and calls it with the relevant arguments.
348        """
349        #print "Content-Type: text/html\n\n" ; print self.userRoles
350        # Just print the login page if not logged in and login required
351        if RESTRICTED_DATA==1 and self.loginStatus=="out":
352            self.displayer._displayHTTPHeader()
353            self.displayer._displayHTMLHeader()
354            #print "FIELD STORAGE:", self.fieldStorage
355            self.displayer._displayIntroduction()
356            #print self.loginlist           
357            if SECURITY_MODEL in ("basic", "badc"):
358                self.displayer._displayLoginBar(self.username, self.loginStatus, self.loginMessage)
359            elif SECURITY_MODEL=="ndg":
360                argString="?"
361                for key in self.fieldStorage.keys():
362                  if key.find("datasetURI_")>-1:
363                    if argString!="?": 
364                        gapper="&"
365                    else:
366                        gapper=""
367                    argString=argString+("%s%s=%s" % (gapper, key, self.fieldStorage.getvalue(key)))
368                    if argString=="?": argString=""
369                self.displayer._displayNDGLoginBar(self.loginlist, argString)
370                # Delete field storage so not visible anywhere
371                del self.fieldStorage
372            return     
373                             
374        # Set up SOAP bindings 
375        if CALL_METHOD.upper()=="WS":
376            self.server=WSCaller()
377        elif CALL_METHOD.upper()=="LOCAL":
378            serverLocation=LOCAL_SERVER_PACKAGE
379            sys.path.append(serverLocation)
380            print sys.path
381            self.server=LocalCaller()
382
383        # Get session ID
384        self._getSession()
385       
386        # Check if complete
387        isCompleteStatus=self._checkIfComplete()
388       
389
390        # Perform actions as requested by user
391        if self.args.has_key("action"):
392            actionReturn=self._performActions()
393            if actionReturn=="Display footer then complete":
394                return
395       
396        # Clear request if required
397        if self.args.has_key("clearRequest") or self.args.has_key("newRequest"):
398            if self.args.has_key("clearRequest"):
399                del self.args["clearRequest"]
400            else:
401                del self.args["newRequest"] 
402            self.sessionID, self.secureToken=self.server.callServerMethod("newRequest", 
403                                                  [self.sessionID, self.secureToken])                                           
404
405        # Make sure instance and args sessionID are the same
406        self.args["sessionID"]=self.sessionID
407       
408        # Ensure args contains secureToken object
409        if not self.args.has_key("secureToken"): 
410            self.args["secureToken"]=self.secureToken
411
412        # Get the options (and make selections if appropriate)
413        (optionCategories, options, optionStrings, summaryString, secureToken)=self._getLatestOptions() 
414       
415        # Get summary of request and determine number of datasets   
416        #self.summary=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0]
417           
418        # Analyse the request
419        self._respondToOptionCategories(optionCategories, options, optionStrings, summaryString)       
420   
421       
422    def _getSession(self):
423        """
424        Checks if a session is already underway and starts one if not.
425        """           
426        # If no session then start a session and get a sessionID
427        if not self.args.has_key("sessionID") or self.args["sessionID"] in (None, "None", "undefined"):
428            # Start session if not known about
429            #print "Content-type: text/html\n\n", self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])
430            if zsiv>=2.0:
431                self.sessionID, self.secureToken=self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])[0]
432            else:
433                self.sessionID, self.secureToken=self.server.callServerMethod("startSession", [self.username, self.password, self.secureToken])
434        else:
435            self.sessionID=self.args["sessionID"] 
436           
437           
438    def _checkIfComplete(self):
439        """
440        Checks if complete, returns 1 (yes) or 0 (no).
441        """
442        isCompleteStatus=0       
443        if self.args.has_key("isComplete"):     
444            isCompleteStatus, self.secureToken=self.server.callServerMethod("isComplete", 
445                                                      [self.sessionID, self.secureToken])     
446        return isCompleteStatus
447       
448       
449    def _performActions(self):
450        """
451        If "action" argument received then do the appropriate action.
452        """     
453        if 1:  # Move all back <-- one tab and delete this line
454            action=self.args["action"]
455            if action=="viewRequestSummary":
456                summaryString=self.server.callServerMethod("summariseRequest", [self.sessionID, self.secureToken])[0]
457                if zsiv>=2.0:
458                    summaryString=summaryString[0][0]
459
460                self.displayer._displayHTMLHeader()
461                if RESTRICTED_DATA==1: 
462                    roleString=",".join(self.userRoles)
463                    self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+roleString)
464                self.displayer._displayRequestSummaryTable(createSummaryDict(summaryString))
465                self.displayer._displayReturnLine(self.sessionID)
466                return "Display footer then complete"
467
468            elif action=="saveRequest":
469                x=self.server.callServerMethod("getDataSubsetSpecifier",
470                                                           [self.sessionID, self.secureToken])
471
472                #dataSubsetSpecifier, self.secureToken=x                                           
473                self.displayer._displayHTTPHeader() 
474                self.displayer._displayHTMLHeader()     
475                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))       
476                self.displayer._displaySaveRequestOptions(dataSubsetSpecifier, self.sessionID)
477                self.displayer._displayReturnLine(self.sessionID)
478                return "Display footer then complete"
479               
480            elif action=="uploadRequest":
481                self.displayer._displayHTTPHeader() 
482                self.displayer._displayHTMLHeader()
483                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
484                self.displayer._displayUploadRequestOptions(self.sessionID)
485                self.displayer._displayReturnLine(self.sessionID)               
486                return "Display footer then complete"           
487               
488            elif action=="parseUploadedFile":
489                xmlFileString=self.tempFileLink.read()
490                status, self.secureToken=self.server.callServerMethod("uploadRequest", 
491                                              [self.sessionID, xmlFileString, self.secureToken])
492
493            elif action=="getStatus":
494                response=self.server.callServerMethod("getStatus", [self.sessionID, self.secureToken])
495                if zsiv>=2.0:
496                    response=response[0]
497               
498                (status, errorString, outputFilePaths, self.secureToken)=response
499                status=status[0]
500                outputFilePaths=outputFilePaths[0]
501               
502                self.displayer._displayHTTPHeader()
503                #print outputFilePaths
504                self.displayer._displayHTMLHeader()
505                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
506                self.displayer._displayStatus(status, errorString, self.sessionID)
507                if status=="complete":
508                    self.displayer._displayOutputFileList(outputFilePaths)
509                return "Display footer then complete"
510       
511
512
513         
514    def _getLatestOptions(self):
515        """
516        If target page provided then get the options for that page,
517        otherwise get whatever options are presented by the dx and
518        send latest selections to update request.
519        """
520        if self.args.has_key("targetPage"):
521            tp=self.args["targetPage"]
522            tp2catMap={"DatasetGroupPage":"datasetGroup", "DatasetPage":"dataset",
523                       "VariablesPage":"variable", "DomainAndFormatPage":"domainAndFormat"}
524            optionCategory=tp2catMap[tp]
525            self.args["optionCategoryRequested"]=optionCategory
526            # Need to delete targetPage otherwise it will stay forever
527            del self.args["targetPage"]
528
529        response=self.server.callServerMethod("selectOptions", [self.sessionID, self._packArgsAsList(self.args)])
530        #self.displayer._displayHTTPHeader()
531        #print response, type(response)
532        (optionCategories, options, optionStrings, summaryString, secureToken)=self._translateResponse(response)       
533        #print (optionCategories, options, optionStrings, summaryString, secureToken)   
534        return (optionCategories, options, optionStrings, summaryString, secureToken)
535
536   
537    def _translateResponse(self, response):
538        """
539        Takes an object received from the WS and translates to:
540        (optionCategories, options, optionStrings, secureToken)
541        """
542        response=response[0]       
543        if zsiv>=2.0:
544            response=response[0][0]
545        optionCategories=[item[0] for item in response[:-2]]
546        options=[item[1] for item in response[:-2]]
547        optionStrings=options
548        summaryString=response[-2]
549        secureToken=response[-1]               
550        return (optionCategories, options, optionStrings, summaryString, secureToken)
551       
552
553    def _respondToOptionCategories(self, optionCategories, options, optionStrings, summaryString):
554        """
555        Work out what the option category is and respond by displaying
556        the appropriate user interface.
557        """     
558        summaryDict=createSummaryDict(summaryString)
559        # Analyse the option categories now
560        if optionCategories=="No category" or optionCategories==[]:
561            optcat=None
562        else:
563            optcat=optionCategories[0].split("_")[0]
564       
565        if optcat==None and (RESTRICTED_DATA==1 and summaryString.find("dataset")<0):
566            self.displayer._displayHTTPHeader()
567            self.displayer._displayHTMLHeader() 
568            print "<P><B>You do not have the credentials to view any datasets - Sorry!</B><P>" 
569       
570        # Can display simple form for these categories 
571        elif optcat in ("datasetGroup", "dataset", "variable"):         
572            self.displayer._displayHTTPHeader()
573            self.displayer._displayHTMLHeader()     
574            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
575            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID)
576            self.displayer._displayMainTableHeader(self.sessionID)
577            self.displayer._displayOptionsTable(summaryDict, optionCategories, options, optionStrings, self.sessionID, self.sessionObject)
578            self.displayer._displayMainTableFooter()
579       
580        # Need to make a number of web service calls to get information
581        # for each domain as well as output format which are all
582        # displayed on the same page.   
583        elif optcat=="axis":
584            self.displayer._displayHTTPHeader() 
585            self.displayer._displayHTMLHeader()
586            if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
587            self.displayer._displayDatasetSummaryLine(summaryString, optionCategories[0], self.sessionID)
588            self.displayer._displayMainTableHeader(self.sessionID, onSubmit=""" onSubmit='return validateAllTimeSelections("off")'""")
589            self.displayer._displayDomainOptions(summaryDict, optionCategories, options, optionStrings, self.sessionID)
590            self.displayer._displayMainTableFooter()
591               
592        elif optcat==None: 
593            # If there are no option categories then the request is likely to be complete
594            # Display confirmation page if needed
595            if CONFIRMATION_PAGE==1 and not self.args.has_key("confirm"):
596                self.displayer._displayHTTPHeader() 
597                self.displayer._displayHTMLHeader()
598                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
599                self.displayer._displayDatasetSummaryLine(summaryString, optionCategories, self.sessionID)         
600                self.displayer._displayMainTableHeader(self.sessionID)   
601
602                # Get request costs here...
603                response=self.server.callServerMethod("getExtractionCosts", [self.sessionID, self.secureToken])
604                if zsiv>=2.0:
605                    response=response[0]
606                (estimatedDuration, estimatedVolume)=response[0:2]
607                summaryDict["globals"]["estimatedDuration"]=estimatedDuration
608                summaryDict["globals"]["estimatedVolume"]=estimatedVolume
609                #print '<INPUT NAME="action" TYPE="hidden" VALUE="requestCosts">'
610                self.displayer._displayConfirmationSection(summaryDict)
611               
612            # Or display final job processing page     
613            elif self.args.has_key("action") and self.args["action"]=="requestCosts":   
614                response=self.server.callServerMethod("getExtractionCosts", 
615                                                          [self.sessionID, self.secureToken])  #[0][0:2]
616                if zsiv>=2.0:
617                    response=response[0]
618
619                (estimatedDuration, estimatedVolume)=response[0:2]
620                self.displayer._displayHTTPHeader() 
621                self.displayer._displayHTMLHeader()
622                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
623                self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID)
624                response=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])  #[0]
625               
626                if zsiv>=2.0:
627                    response=response[0]
628                pathList, self.secureToken=response
629                #print "<P>", pathList, len(pathList)
630                self.displayer._displayOutputFileList(pathList) 
631
632            elif self.args.has_key("action") and self.args["action"]=="getOutput":
633                self.displayer._displayHTTPHeader()
634                self.displayer._displayHTMLHeader()
635                if RESTRICTED_DATA==1: self.displayer._displayLoginBar(self.username, loginStatus="in", loginMessage="with roles: "+str(self.userRoles))
636                estimatedDuration=float(summaryDict["globals"]["estimatedDuration"])
637                estimatedVolume=float(summaryDict["globals"]["estimatedVolume"])
638                self.displayer._displayProcessingSection(estimatedDuration, estimatedVolume, self.sessionID)
639                response=self.server.callServerMethod("createOutput", [self.sessionID, self.secureToken])  #[0]
640
641                if zsiv>=2.0:
642                    response=response[0]
643                pathList, self.secureToken=response
644                #print "<P>", pathList, len(pathList)
645                #self.displayer._displayOutputFileList(pathList)
646
647
648
649    def _packArgsAsList(self, args):
650        """
651        In order to work with ZSI SOAP library need to pack up arguments as a list
652        of [keyword, value] pairs rather than a dictionary.
653        """
654        newList=[]
655        for key, value in args.items():
656            newList.append([key, value])
657        return newList
658       
659
660if __name__=="__main__":
661
662    DXCGIClient()       
Note: See TracBrowser for help on using the repository browser.