source: trunk/gui/scripts/tool.tcl @ 3275

Last change on this file since 3275 was 3275, checked in by gah, 8 years ago

fix java search, fix error message for logger

File size: 15.0 KB
Line 
1# ----------------------------------------------------------------------
2#  COMPONENT: tool - represents an entire tool
3#
4#  This object represents an entire tool defined by Rappture.
5#  Each tool resides in an installation directory with other tool
6#  resources (libraries, examples, etc.).  Each tool is defined by
7#  its inputs and outputs, which are tied to various widgets in the
8#  GUI.  Each tool tracks the inputs, knows when they're changed,
9#  and knows how to run itself to produce new results.
10# ======================================================================
11#  AUTHOR:  Michael McLennan, Purdue University
12#  Copyright (c) 2004-2012  HUBzero Foundation, LLC
13#
14#  See the file "license.terms" for information on usage and
15#  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
16# ======================================================================
17package require BLT
18
19itcl::class Rappture::Tool {
20    inherit Rappture::ControlOwner
21
22    constructor {xmlobj installdir args} {
23        Rappture::ControlOwner::constructor ""
24    } { # defined below }
25
26    destructor { # defined below }
27
28    public method installdir {} { return $_installdir }
29
30    public method run {args}
31    public method abort {}
32    public method reset {}
33
34    protected method _mkdir {dir}
35    protected method _output {data}
36
37    private variable _origxml ""     ;# copy of original XML (for reset)
38    private variable _installdir ""  ;# installation directory for this tool
39    private variable _outputcb ""    ;# callback for tool output
40    private common job               ;# array var used for blt::bgexec jobs
41    private common jobnum 0          ;# counter for unique job number
42
43    # get global resources for this tool session
44    public proc resources {{option ""}}
45
46    public common _resources
47    public proc setAppName {name}   { set _resources(-appname) $name }
48    public proc setHubName {name}   { set _resources(-hubname) $name }
49    public proc setHubURL {name}    { set _resources(-huburl) $name }
50    public proc setSession {name}   { set _resources(-session) $name }
51    public proc setJobPrt {name}    { set _resources(-jobprotocol) $name }
52    public proc setResultDir {name} { set _resources(-resultdir) $name }
53}
54
55# must use this name -- plugs into Rappture::resources::load
56proc tool_init_resources {} {
57    Rappture::resources::register \
58        application_name  Rappture::Tool::setAppName \
59        application_id    Rappture::Tool::setAppId \
60        hub_name          Rappture::Tool::setHubName \
61        hub_url           Rappture::Tool::setHubURL \
62        session_token     Rappture::Tool::setSession \
63        job_protocol      Rappture::Tool::setJobPrt \
64        results_directory Rappture::Tool::setResultDir
65}
66
67# ----------------------------------------------------------------------
68# CONSTRUCTOR
69# ----------------------------------------------------------------------
70itcl::body Rappture::Tool::constructor {xmlobj installdir args} {
71    if {![Rappture::library isvalid $xmlobj]} {
72        error "bad value \"$xmlobj\": should be Rappture::Library"
73    }
74    set _xmlobj $xmlobj
75
76    # stash a copy of the original XML for later "reset" operations
77    set _origxml [Rappture::LibraryObj ::#auto "<?xml version=\"1.0\"?><run/>"]
78    $_origxml copy "" from $_xmlobj ""
79
80    if {![file exists $installdir]} {
81        error "directory \"$installdir\" doesn't exist"
82    }
83    set _installdir $installdir
84
85    eval configure $args
86}
87
88# ----------------------------------------------------------------------
89# DESTRUCTOR
90# ----------------------------------------------------------------------
91itcl::body Rappture::Tool::destructor {} {
92    itcl::delete object $_origxml
93}
94
95# ----------------------------------------------------------------------
96# USAGE: resources ?-option?
97#
98# Clients use this to query information about the tool.
99# ----------------------------------------------------------------------
100itcl::body Rappture::Tool::resources {{option ""}} {
101    if {$option == ""} {
102        return [array get _resources]
103    }
104    if {[info exists _resources($option)]} {
105        return $_resources($option)
106    }
107    return ""
108}
109
110# ----------------------------------------------------------------------
111# USAGE: run ?<path1> <value1> <path2> <value2> ...? ?-output <callbk>?
112#
113# This method causes the tool to run.  All widgets are synchronized
114# to the current XML representation, and a "driver.xml" file is
115# created as the input for the run.  That file is fed to the tool
116# according to the <tool><command> string, and the job is executed.
117#
118# Any "<path> <value>" arguments are used to override the current
119# settings from the GUI.  This is useful, for example, when filling
120# in missing simulation results from the analyzer.
121#
122# If the -output argument is included, then the next arg is a
123# callback command for output messages.  Any output that comes in
124# while the tool is running is sent back to the caller, so the user
125# can see progress running the tool.
126#
127# Returns a list of the form {status result}, where status is an
128# integer status code (0=success) and result is the output from the
129# simulator.  Successful output is something like {0 run1293921.xml},
130# where 0=success and run1293921.xml is the name of the file containing
131# results.
132# ----------------------------------------------------------------------
133itcl::body Rappture::Tool::run {args} {
134    global errorInfo
135
136    #
137    # Make sure that we save the proper application name.
138    # Actually, the best place to get this information is
139    # straight from the "installtool" script, but just in
140    # case we have an older tool, we should insert the
141    # tool name from the resources config file.
142    #
143    if {[info exists _resources(-appname)]
144          && "" != $_resources(-appname)
145          && "" == [$_xmlobj get tool.name]} {
146        $_xmlobj put tool.name $_resources(-appname)
147    }
148
149    # sync all widgets to the XML tree
150    sync
151
152    # if there are any args, use them to override parameters
153    set _outputcb ""
154    foreach {path val} $args {
155        if {$path == "-output"} {
156            set _outputcb $val
157        } else {
158            $_xmlobj put $path.current $val
159        }
160    }
161
162    foreach item {control output error} { set job($item) "" }
163
164    # write out the driver.xml file for the tool
165    set file "driver[pid].xml"
166    set status [catch {
167        set fid [open $file w]
168        puts $fid "<?xml version=\"1.0\"?>"
169        puts $fid [$_xmlobj xml]
170        close $fid
171    } result]
172
173    # set limits for cpu time
174    set limit [$_xmlobj get tool.limits.cputime]
175    if {"" == $limit || [catch {Rappture::rlimit set cputime $limit}]} {
176        Rappture::rlimit set cputime 900  ;# 15 mins by default
177    }
178
179    # execute the tool using the path from the tool description
180    if {$status == 0} {
181        set cmd [$_xmlobj get tool.command]
182        regsub -all @tool $cmd $_installdir cmd
183        regsub -all @driver $cmd $file cmd
184        regsub -all {\\} $cmd {\\\\} cmd
185        set cmd [string trimleft $cmd " "]
186        if { $cmd == "" } {
187            puts stderr "cmd is empty"
188            return [list 1 "Command is empty.\n\nThere is no command specified by\n\n <command>\n </command>\n\nin the tool.xml file."]
189        }
190        # if job_protocol is "submit", then use use submit command
191        if {[resources -jobprotocol] == "submit"} {
192            set cmd [linsert $cmd 0 submit --local]
193        }
194
195        # starting job...
196        Rappture::Logger::log run started
197        Rappture::rusage mark
198
199        if {0 == [string compare -nocase -length 5 $cmd "ECHO "] } {
200            set status 0;
201            set job(output) [string range $cmd 5 end]
202        } else {
203            set status [catch {
204                set ::Rappture::Tool::job(control) ""
205                eval blt::bgexec \
206                    ::Rappture::Tool::job(control) \
207                    -keepnewline yes \
208                    -killsignal SIGTERM \
209                    -onoutput [list [itcl::code $this _output]] \
210                    -output ::Rappture::Tool::job(output) \
211                    -error ::Rappture::Tool::job(error) \
212                    $cmd
213            } result]
214
215            if { $status != 0 } {
216                # We're here because the exec-ed program failed
217                set logmesg $result
218                if { $::Rappture::Tool::job(control) != "" } {
219                    foreach { token pid code mesg } \
220                        $::Rappture::Tool::job(control) break
221                    if { $token == "EXITED" } {
222                        # This means that the program exited normally but
223                        # returned a non-zero exitcode.  Consider this an
224                        # invalid result from the program.  Append the stderr
225                        # from the program to the message.
226                        set logmesg "Program finished: exit code is $code"
227                        set result "$logmesg\n\n$::Rappture::Tool::job(error)"
228                    } elseif { $token == "abort" }  {
229                        # The user pressed the abort button.
230                        set logmesg "Program terminated by user."
231                        set result "$logmesg\n\n$::Rappture::Tool::job(output)"
232                    } else {
233                        # Abnormal termination
234                        set logmesg "Abnormal program termination: $mesg"
235                        set result "$logmesg\n\n$::Rappture::Tool::job(output)"
236                    }
237                }
238                Rappture::Logger::log run failed [list $logmesg]
239                return [list $status $result]
240            }
241        }
242        # ...job is finished
243        array set times [Rappture::rusage measure]
244
245        if {[resources -jobprotocol] != "submit"} {
246            set id [$_xmlobj get tool.id]
247            set vers [$_xmlobj get tool.version.application.revision]
248            set simulation simulation
249            if { $id != "" && $vers != "" } {
250                set pid [pid]
251                set simulation ${pid}_${id}_r${vers}
252            }
253            puts stderr "MiddlewareTime: job=[incr jobnum] event=$simulation start=$times(start) walltime=$times(walltime) cputime=$times(cputime) status=$status"
254
255            #
256            # Scan through stderr channel and look for statements that
257            # represent grid jobs that were executed.  The statements
258            # look like this:
259            #
260            # MiddlewareTime: job=1 event=simulation start=3.001094 ...
261            #
262            set subjobs 0
263            while {[regexp -indices {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)} $job(error) match]} {
264                foreach {p0 p1} $match break
265                if {[string index $job(error) $p0] == "\n"} { incr p0 }
266
267                catch {unset data}
268                array set data {
269                    job 1
270                    event simulation
271                    start 0
272                    walltime 0
273                    cputime 0
274                    status 0
275                }
276                foreach arg [lrange [string range $job(error) $p0 $p1] 1 end] {
277                    foreach {key val} [split $arg =] break
278                    set data($key) $val
279                }
280                set data(job) [expr {$jobnum+$data(job)}]
281                set data(event) "subsimulation"
282                set data(start) [expr {$times(start)+$data(start)}]
283
284                set stmt "MiddlewareTime:"
285                foreach key {job event start walltime cputime status} {
286                    # add required keys in a particular order
287                    append stmt " $key=$data($key)"
288                    unset data($key)
289                }
290                foreach key [array names data] {
291                    # add anything else that the client gave -- venue, etc.
292                    append stmt " $key=$data($key)"
293                }
294                puts stderr $stmt
295                incr subjobs
296
297                # done -- remove this statement
298                set job(error) [string replace $job(error) $p0 $p1]
299            }
300            incr jobnum $subjobs
301        }
302
303    } else {
304        set job(error) "$result\n$errorInfo"
305    }
306    if {$status == 0} {
307        file delete -force -- $file
308    }
309
310    # see if the job was aborted
311    if {[regexp {^KILLED} $job(control)]} {
312        Rappture::Logger::log run aborted
313        return [list 0 "ABORT"]
314    }
315
316    #
317    # If successful, return the output, which should include
318    # a reference to the run.xml file containing results.
319    #
320    if {$status == 0} {
321        set result [string trim $job(output)]
322        if {[regexp {=RAPPTURE-RUN=>([^\n]+)} $result match file]} {
323            set status [catch {Rappture::library $file} result]
324            if {$status != 0} {
325                global errorInfo
326                set result "$result\n$errorInfo"
327            }
328
329            # if there's a results_directory defined in the resources
330            # file, then move the run.xml file there for storage
331            if {[info exists _resources(-resultdir)]
332                  && "" != $_resources(-resultdir)} {
333                catch {
334                    if {![file exists $_resources(-resultdir)]} {
335                        _mkdir $_resources(-resultdir)
336                    }
337                    file rename -force -- $file $_resources(-resultdir)
338                }
339            }
340        } else {
341            set status 1
342            set result "Can't find result file in output.\nDid you call Rappture
343::result in your simulator?"
344        }
345    } elseif {$job(output) ne "" || $job(error) ne ""} {
346        set result [string trim "$job(output)\n$job(error)"]
347    }
348
349    # log final status for the run
350    if {$status == 0} {
351        Rappture::Logger::log run finished
352    } else {
353        Rappture::Logger::log run failed [list $result]
354    }
355
356    return [list $status $result]
357}
358
359# ----------------------------------------------------------------------
360# USAGE: _mkdir <directory>
361#
362# Used internally to create the <directory> in the file system.
363# The parent directory is also created, as needed.
364# ----------------------------------------------------------------------
365itcl::body Rappture::Tool::_mkdir {dir} {
366    set parent [file dirname $dir]
367    if {"." != $parent && "/" != $parent} {
368        if {![file exists $parent]} {
369            _mkdir $parent
370        }
371    }
372    file mkdir $dir
373}
374
375
376# ----------------------------------------------------------------------
377# USAGE: abort
378#
379# Clients use this during a "run" to abort the current job.
380# Kills the job and forces the "run" method to return.
381# ----------------------------------------------------------------------
382itcl::body Rappture::Tool::abort {} {
383    Rappture::Logger::log run abort
384    set job(control) "abort"
385}
386
387# ----------------------------------------------------------------------
388# USAGE: reset
389#
390# Resets all input values to their defaults.  Sometimes used just
391# before a run to reset to a clean state.
392# ----------------------------------------------------------------------
393itcl::body Rappture::Tool::reset {} {
394    $_xmlobj copy "" from $_origxml ""
395    foreach path [Rappture::entities -as path $_xmlobj input] {
396        if {[$_xmlobj element -as type $path.default] ne ""} {
397            set defval [$_xmlobj get $path.default]
398            $_xmlobj put $path.current $defval
399        }
400    }
401}
402
403# ----------------------------------------------------------------------
404# USAGE: _output <data>
405#
406# Used internally to send each bit of output <data> coming from the
407# tool onto the caller, so the user can see progress.
408# ----------------------------------------------------------------------
409itcl::body Rappture::Tool::_output {data} {
410    if {[string length $_outputcb] > 0} {
411        uplevel #0 $_outputcb [list $data]
412    }
413}
Note: See TracBrowser for help on using the repository browser.