Changeset 6473

Timestamp:

Aug 7, 2016 6:08:40 PM (8 years ago)

Author:

ldelgass

Message:

Merge simsets, result cache (instant-on) from release branches.

Location:

trunk

Files:

• . (modified) (1 prop)
• gui/apps/launcher.tcl (modified) (6 diffs)
• gui/scripts/analyzer.tcl (modified) (13 diffs)
• gui/scripts/images/hamburger_menu.png (copied) (copied from branches/1.4/gui/scripts/images/hamburger_menu.png)
• gui/scripts/loader.tcl (modified) (4 diffs)
• gui/scripts/main.tcl (modified) (6 diffs)
• gui/scripts/pager.tcl (modified) (2 diffs)
• lang/tcl/scripts/task.tcl (modified) (9 diffs)
• src/core/RpLibrary.cc (modified) (2 diffs)

trunk/gui/apps/launcher.tcl

@@ -1 +1 @@
 #!/bin/sh
-# -*- mode: Tcl -*-
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  RAPPTURE LAUNCHER
@@ -44 +44 @@
 
 set rapptureInfo(cwd) [pwd]
+set rapptureInfo(appName) ""
 
 if {[info exists env(TOOL_PARAMETERS)]} {
@@ -80 +81 @@
                             lappend params(load) $value
                             set params(opt) "-load"
+                        }
+                        "(simset)" - "" {
+                            lappend params(simset) $value
+                            set params(opt) "-simset"
                         }
                         "(execute)" {
@@ -176 +181 @@
                 }
             }
+            -simset {
+                lappend alist $opt [lindex $argv 0]
+                set argv [lrange $argv 1 end]
+            }
+            -appname {
+                global rapptureInfo
+                set rapptureInfo(appName) [lindex $argv 0]
+                set argv [lrange $argv 1 end]
+            }
             default {
                 puts stderr "usage:"
@@ -202 +216 @@
             set reqpkgs Tk
         }
+        -simset {
+            # add tool parameters to the end of any files given on cmd line
+            set loadlist [concat $loadlist $params(simset)]
+            set alist [concat $alist -simset $loadlist]
+
+            package require RapptureGUI
+            set guidir $RapptureGUI::library
+            set mainscript [file join $guidir scripts main.tcl]
+            set reqpkgs Tk
+        }
         -execute {
             if {[llength $params(execute)] != 1} {
@@ -260 +284 @@
 # Note: We're sourcing the driver file "main.tcl" rather than exec-ing
 #       wish because we want to see stderr and stdout messages when they
-#       are written, rather than when the program completes.  It also
-#       eliminates one process waiting for the other to complete. If
-#       "exec" is needed, then the following could be replaced with
-#       blt::bgexec.  It doesn't try to redirect stderr into a file.
+#       are written, rather than when the program completes.  It also
+#       eliminates one process waiting for the other to complete. If
+#       "exec" is needed, then the following could be replaced with
+#       blt::bgexec.  It doesn't try to redirect stderr into a file.
 set argv $alist
 foreach name $reqpkgs {

trunk/gui/scripts/analyzer.tcl

@@ -60 +60 @@
     public method reset {{when -eventually}}
     public method load {xmlobj}
+    public method reload { fileName }
     public method clear {{xmlobj "all"}}
     public method download {option args}
+    public method buildMenu { w url appName }
 
     protected method _plot {args}
@@ -83 +85 @@
     protected method _adjust_level {win}
 
+    private variable _done 0
+    private variable _tree ""
+    private variable _saved 
+    private variable _name "" 
+    private variable _revision 0;       # Tool revision
     private variable _tool ""          ;# belongs to this tool
     private variable _appName ""       ;# Name of application
@@ -94 +101 @@
     private variable _plotlist ""      ;# items currently being plotted
     private variable _lastPlot
-    private common job                 ;# array var used for blt::bgexec jobs
     private variable _uq_active 0      ;# a UQ variables has been used
     private variable _wait_uq 0
+    private common job                 ;# array var used for blt::bgexec jobs
+
+    private method BuildQuestionDialog { popup }
+    private method BuildSimulationTable { w }
+    private method Cancel {}
+    private method CheckSimsetDetails {}
+    private method CleanName { name }
+    private method CreateSharedPath { path } 
+    private method EditSimset {}
+    private method ExportFile { src msgFile }
+    private method ExportURL { appName installdir } 
+    private method FindSimsetsForApp { appName }
+    private method GetSimset { name }
+    private method InstallSharedFile { installdir file } 
+    private method LoadSimulations { runfiles }
+    private method Ok {}
+    private method OverwriteSaveFile {}
+    private method PostMenu { menu }
+    private method ReadSimsetFile { fileName }
+    private method Save {}
+    private method SaveSimulations {}
+    private method SelectSimsetForDeletion {}
+    private method SelectSimsetForLoading {}
+    private method SelectSimsetNameAndSave {}
+    private method SelectSimsetToShare {}
+    private method WriteSimsetFile { appName fileName share }
 }
 
@@ -108 +140 @@
 itcl::body Rappture::Analyzer::constructor {tool args} {
     set _tool $tool
+    set _tree [blt::tree create]
 
     # use this to store all simulation results
@@ -149 +182 @@
 
     # if there's a hub url, then add "About" and "Questions" links
-    set _appName [$_tool xml get tool.id]
+    global rapptureInfo
+    if { $rapptureInfo(appName) == "" } {
+        set _appName [$_tool xml get "tool.id"]
+    } else {
+        set _appName $rapptureInfo(appName)
+    }
+    set num [$_tool xml get "tool.version.application.revision"]
+    if { $num == "" } {
+        set num 0
+    }
+    set _revision $num
     set url [Rappture::Tool::resources -huburl]
-    if {"" != $url && "" != $_appName} {
-        itk_component add hubcntls {
-            frame $itk_component(simbg).hubcntls
-        } {
-            usual
-            rename -background -simcontrolcolor simControlColor Color
-        }
-        pack $itk_component(hubcntls) -side right -padx 4
-
-        itk_component add icon {
-            label $itk_component(hubcntls).icon -image [Rappture::icon ask] \
-                -highlightthickness 0
-        } {
-            usual
-            ignore -highlightthickness
-            rename -background -simcontrolcolor simControlColor Color
-        }
-        pack $itk_component(icon) -side left
-
-        itk_component add about {
-            button $itk_component(hubcntls).about -text "About this tool" \
-                -command [list Rappture::filexfer::webpage \
-                              "$url/tools/$_appName"]
-        } {
-            usual
-            ignore -font
-            rename -background -simcontrolcolor simControlColor Color
-            rename -highlightbackground -simcontrolcolor simControlColor Color
-        }
-        pack $itk_component(about) -side top -anchor w
-
-        itk_component add questions {
-            button $itk_component(hubcntls).questions -text Questions? \
-                -command [list Rappture::filexfer::webpage \
-                              "$url/resources/$_appName/questions"]
-        } {
-            usual
-            ignore -font
-            rename -background -simcontrolcolor simControlColor Color
-            rename -highlightbackground -simcontrolcolor simControlColor Color
-        }
-        pack $itk_component(questions) -side top -anchor w
-    }
-
+
+    itk_component add hubcntls {
+        frame $itk_component(simbg).hubcntls
+    } {
+        usual
+        rename -background -simcontrolcolor simControlColor Color
+    }
+    pack $itk_component(hubcntls) -side right -padx 4
+    
+    itk_component add help {
+        menubutton $itk_component(hubcntls).help \
+            -image [Rappture::icon hamburger_menu] \
+            -highlightthickness 0 \
+            -menu $itk_component(hubcntls).help.menu
+    } {
+        usual
+        ignore -highlightthickness
+        rename -background -simcontrolcolor simControlColor Color
+    }
+    pack $itk_component(help) -side left
+    buildMenu $itk_component(help).menu $url $_appName
+    
     itk_component add simstatus {
         text $itk_component(simbg).simstatus -borderwidth 0 \
@@ -399 +420 @@
 # ----------------------------------------------------------------------
 itcl::body Rappture::Analyzer::simulate {args} {
-    #puts "simulate args='$args'"
 
     set uq [$_tool get_uq -uq_type smolyak -uq_args 2]
@@ -426 +446 @@
         # check to see if simulation is really needed
         $_tool sync
-        if {[$_resultset contains [$_tool xml object]]
-              && ![string equal $_control "manual-resim"]} {
+        if {[$_resultset contains [$_tool xml object]] &&
+            ![string equal $_control "manual-resim"]} {
             # not needed -- show results and return
             $itk_component(notebook) current analyze
@@ -518 +538 @@
     # check to see if simulation is really needed
     $_tool sync
-    if {![$_resultset contains [$_tool xml object]]
-          || [string equal $_control "manual-resim"]} {
+    if {![$_resultset contains [$_tool xml object]] ||
+        [string equal $_control "manual-resim"]} {
         # if control mode is "auto", then simulate right away
         if {[string match auto* $_control]} {
@@ -1110 +1130 @@
     # Scan through and pick out any =RAPPTURE-PROGRESS=> messages first.
     #
-
-    while {[regexp -indices \
-               {=RAPPTURE-PROGRESS=> *([-+]?[0-9]+) +([^\n]*)(\n|$)} $message \
-                match percent mesg]} {
+    set pattern {=RAPPTURE-PROGRESS=> *([-+]?[0-9]+) +([^\n]*)(\n|$)}
+    while {[regexp -indices $pattern $message match percent mesg]} {
 
         foreach {i0 i1} $percent break
@@ -1155 +1173 @@
     #
     $itk_component(runinfo) configure -state normal
-
-    while {[regexp -indices \
-               {=RAPPTURE-([a-zA-Z]+)=>([^\n]*)(\n|$)} $message \
-                match type mesg]} {
-
+    set pattern {=RAPPTURE-([a-zA-Z]+)=>([^\n]*)(\n|$)}
+    while {[regexp -indices $pattern $message match type mesg]} {
         foreach {i0 i1} $match break
         set first [string range $message 0 [expr {$i0-1}]]
@@ -1202 +1217 @@
     set name [$itk_component(viewselector) value]
     if {[info exists _label2desc($name)] &&
-         [string length $_label2desc($name)] > 0} {
+        [string length $_label2desc($name)] > 0} {
         append tip "$_label2desc($name)\n\n"
     }
@@ -1470 +1485 @@
             continue
         }
-        if 0 {
-        # Recurse over all child nodes.
-        _trajToSequence $xmlobj $current
-        }
     }
 }
@@ -1498 +1509 @@
     _fixNotebook
 }
+
+itcl::body Rappture::Analyzer::PostMenu { m } {
+    if { [FindSimsetsForApp $_appName] == 0 } {
+        $m entryconfigure "Load Simulations" -state disable
+        $m entryconfigure "Share Simulations" -state disable
+        $m entryconfigure "Delete Simulations" -state disabled
+    } else {
+        $m entryconfigure "Load Simulations" -state normal
+        $m entryconfigure "Share Simulations" -state normal
+        $m entryconfigure "Delete Simulations" -state normal
+    }
+    if { [$_resultset size] == 0 } {
+        $m entryconfigure "Save Simulations" -state disabled
+    } else {
+        $m entryconfigure "Save Simulations" -state normal
+    }
+}
+        
+#
+# Build Help menu 
+#
+itcl::body Rappture::Analyzer::buildMenu { m url appName } {
+    menu $m \
+        -tearoff 0 \
+        -postcommand [itcl::code $this PostMenu $m]
+    if { $appName == "" || $url == "" } {
+        set state disabled
+    } else {
+        set state normal
+    }
+    set webcmd Rappture::filexfer::webpage
+    set group "app-$_appName"
+    if { [info exists env(SESSION)] }  {
+        set referer "&referrer=$url/tools/$appName/session?sess=$env(SESSION)"
+    } else {
+        set referer ""
+    }
+    $m add command -label "About this tool" \
+        -command [list $webcmd "$url/tools/$appName"] \
+        -state $state
+    $m add command -label "Questions?" \
+        -command [list $webcmd "$url/resources/$_appName/questions"] \
+        -state $state
+    $m add command -label "Tickets" -state $state \
+        -command [list $webcmd "$url/feedback/report_problems?group=$group$referer"]
+    $m add command -label "Wish List" -state disabled
+    $m add separator
+    $m add command -label "Save Simulations" \
+        -command [itcl::code $this SelectSimsetNameAndSave] \
+        -state $state
+    $m add command -label "Load Simulations" \
+        -command [itcl::code $this SelectSimsetForLoading] \
+        -state $state
+    $m add command -label "Delete Simulations" \
+        -command [itcl::code $this SelectSimsetForDeletion] \
+        -state $state
+    $m add command -label "Share Simulations" \
+        -command [itcl::code $this SelectSimsetToShare] \
+        -state $state
+    return $m
+}
+
+itcl::body Rappture::Analyzer::BuildSimulationTable { top } {
+    # All weirdness is due to the Resultset object.
+
+    # First create nodes for each simulation.  The node label is the
+    # simulation number (such as #1, #2, etc).  
+    eval $_tree delete 0
+    set labels "selected simnum"
+    foreach {name index} [$_resultset diff values simnum] {
+        set node [$_tree insert 0 -label $name]
+        $_tree set $node "simnum" $name
+        set index2name($index) $name
+        
+    }
+    # Next fill in the xmlobj associated with each simulation.  We assume
+    # that the order is the the same as the simulation number.
+    set index 0
+    foreach {xmlobj dummy} [$_resultset diff values xmlobj]  {
+        set node [$_tree findchild 0 $index2name($index)]
+        set runfile [$xmlobj get output.filename]
+        set version [$xmlobj get output.version]
+        $_tree set $node \
+            "selected" 1 "xmlobj" $xmlobj "runfile" $runfile "version" $version
+        incr index
+    }
+    # Finally for each different input, for each simulation add the
+    # label and value for the specific input.
+    foreach name [$_resultset diff names] {
+        # Ignore non-input names.
+        if { $name == "xmlobj" || $name == "simnum" } {
+            continue
+        }
+        foreach node [$_tree children 0] {
+            set xmlobj [$_tree get $node xmlobj]
+            set label [$xmlobj get $name.about.label]
+            set value [$xmlobj get $name.current]
+            if { [$_tree exists $node $label] } {
+                puts stderr "This can't be: $label already exists in $node"
+            }
+            if { [lsearch $labels $label] < 0 } {
+                lappend labels $label
+            }
+            $_tree set $node $label $value
+        }
+    }
+    frame $top
+    set tv $top.tv
+    blt::treeview $top.tv -tree $_tree \
+        -height 1i \
+        -xscrollcommand [list $top.xs set] \
+        -yscrollcommand [list $top.ys set] \
+        -font "Arial 10"
+    scrollbar $top.xs -orient horizontal -command "$tv xview"
+    scrollbar $top.ys -orient vertical -command "$tv yview"
+        
+    eval $tv column insert end $labels
+    $tv style checkbox checkbox -showvalue no 
+    $tv column configure simnum -title "Simulation" 
+    $tv column configure selected -title "Save" -style checkbox \
+        -width .5i -edit yes 
+    $tv column configure treeView -hide yes 
+    blt::table $top \
+        0,0 $top.tv -fill both \
+        0,1 $top.ys -fill y \
+        1,0 $top.xs -fill x
+    blt::table configure $top r* c* -resize none
+    blt::table configure $top r0 c0 -resize both
+}
+
+itcl::body Rappture::Analyzer::CleanName { name } {
+    regsub -all {/} $name {_} name
+    return $name
+}
+
+#
+# Get the results and display them in a table.
+#
+# Use the table to omit specific results
+# Use file chooser to save to specific 
+itcl::body Rappture::Analyzer::SelectSimsetNameAndSave {} {
+    if { [EditSimset] } {
+        set name [CleanName $_saved(Name)]
+        set saveDir [file join ~/data/saved $_appName $name]
+        set saveDir [file normalize $saveDir]
+        file mkdir $saveDir 
+        set fileName [file join $saveDir $name.sav]
+        if { [file exists $fileName] } {
+            if { ![OverwriteSaveFile] } {
+                return
+            }
+        }
+        WriteSimsetFile $_appName $fileName 0
+    }
+}
+
+#
+# Get the results and display them in a table.
+#
+# Use the table to omit specific results
+# Use file chooser to save to specific 
+itcl::body Rappture::Analyzer::SelectSimsetToShare {} {
+    if { [GetSimset "share"] } {
+        global env
+        set name [CleanName $_saved(Name)]
+        set shareDir [file join /data/tools/shared $env(USER) $_appName $name]
+        if { [catch {
+            CreateSharedPath $shareDir
+        } errs] != 0 } {
+            puts stderr errs=$errs
+            return 
+        }
+        set fileName [file join $shareDir $name.sav]
+        if { [file exists $fileName] } {
+            if { ![OverwriteSaveFile] } {
+                return
+            }
+        }
+        WriteSimsetFile $_appName $fileName 1
+        ExportURL $_appName $shareDir
+    }
+}
+
+#
+# Checks editor widgets to see if the name and description have been
+# set.  If this is so it enables the save button in the editor.
+#
+itcl::body Rappture::Analyzer::CheckSimsetDetails {} {
+    set popup .savesimset
+    if { ![winfo exists $popup] } {
+        return
+    }
+    set inner [$popup component inner]
+    set name [string trim [$inner.name get]]
+    set desc [string trim [$inner.desc get 0.0 end]]
+    $inner.controls.save configure -state disabled
+    if { $name == "" || $desc == "" } {
+        return
+    }
+    $inner.controls.save configure -state normal
+}
+
+#
+# Gathers all the information from the simset editor into the _saved array
+#
+itcl::body Rappture::Analyzer::SaveSimulations {} {
+    set popup .savesimset
+    if { ![winfo exists $popup] } {
+        return
+    }
+    set inner [$popup component inner]
+    array unset _saved
+    set name [string trim [$inner.name get]]
+    set desc [string trim [$inner.desc get 0.0 end]]
+    set _saved(Application) $_appName
+    set _saved(Revision) $_revision
+    set _saved(Date) [clock format [clock seconds]]
+    set _saved(Name) $name
+    set _saved(Description) $desc
+    set files {}
+    foreach node [$_tree children root] {
+        set fileName [$_tree get $node runfile]
+        lappend files $fileName
+    }
+    set _saved(Files) $files
+    set _done 1 
+}
+
+itcl::body Rappture::Analyzer::Cancel {} {
+    set _done 0
+}
+
+itcl::body Rappture::Analyzer::Ok {} {
+    set popup .selectsimset
+    if { ![winfo exists $popup] } {
+        return
+    }
+    set inner [$popup component inner]
+    set tv $inner.tv
+    if { ![$tv selection present] } {
+        return
+    }
+    set node [$tv curselection]
+    array unset _saved
+    array set _saved [$_tree get $node]
+    set saveDir [file dirname $_saved(FileName)]
+    set files {}
+    foreach file $_saved(Files) {
+        if { [file pathtype $file] == "relative" } {
+            set file [file join $saveDir $file]
+        }
+        lappend files $file
+    }
+    set _saved(Files) $files
+    set _done 1 
+}
+
+#
+# WriteSimsetFile --
+#
+#       Write the .sav file and the runfiles in the 
+#            ~/data/saved/$_appName/$name
+#       directory.  
+# The run files will be in the same directory as the .sav file.  
+# For example, if the simset file is /path/to/appName/myName/myName.sav, 
+# the runfile directory is /path/to/appName/myName.
+#
+itcl::body Rappture::Analyzer::WriteSimsetFile { appName fileName share } {
+    set saveDir [file dirname $fileName]
+    if { [file exists $saveDir] } {
+        file delete -force $saveDir
+    }
+    if { [catch {
+        if { $share } {
+            CreateSharedPath $saveDir
+        } else {
+            file mkdir $saveDir
+        }
+        set f [open $fileName "w"]
+        puts $f [list "Name"        $_saved(Name)]
+        puts $f [list "Description" $_saved(Description)]
+        puts $f [list "Date"        $_saved(Date)]
+        global env
+        puts $f [list "Creator"     $env(USER)]
+        puts $f [list "Application" $_saved(Application)]
+        puts $f [list "Revision"    $_saved(Revision)]
+        set runfiles ""
+        foreach file $_saved(Files) {
+            set tail [file tail $file]
+            set dest [file join $saveDir $tail]
+            if { $share } {
+                InstallSharedFile $saveDir $file
+            } else {
+                file copy -force $file $dest
+            }
+            lappend runfiles $tail
+        }
+        puts $f [list "Files" $runfiles]
+        close $f
+        if { $share } {
+            file attributes $fileName -permissions o+r,g+rw
+        }
+    } errs] != 0 } {
+        global errorInfo
+        puts stderr "errs=$errs errorInfo=$errorInfo"
+    }
+}
+
+itcl::body Rappture::Analyzer::EditSimset {} {
+    set popup .savesimset
+    if { [winfo exists $popup] } {
+        destroy $popup
+    }
+    # Create a popup for the print dialog
+    Rappture::Balloon $popup -title "Save set of simulations..."
+    set inner [$popup component inner]
+
+    label $inner.name_l -text "Simulation Set Name"
+    entry $inner.name -background white
+    label $inner.desc_l -text "Simulation Set Description" -height 5 
+    text $inner.desc  -background white
+    label $inner.select_l -text "Selected Simulations"
+    BuildSimulationTable $inner.select
+    frame $inner.controls
+    bind $inner.desc <KeyPress> [itcl::code $this CheckSimsetDetails]
+    bind $inner.name <KeyPress> [itcl::code $this CheckSimsetDetails]
+    bind $inner.desc <Motion> [itcl::code $this CheckSimsetDetails]
+    bind $inner.name <Motion> [itcl::code $this CheckSimsetDetails]
+    button $inner.controls.cancel -text "Cancel" \
+        -command [itcl::code $this Cancel]
+    button $inner.controls.save -text "Save" \
+        -command [itcl::code $this SaveSimulations]
+    blt::table $inner.controls \
+        0,0 $inner.controls.cancel \
+        0,1 $inner.controls.save
+    
+    blt::table $inner \
+        0,0 $inner.name_l -anchor ne \
+        0,1 $inner.name -fill x \
+        1,0 $inner.desc_l -anchor ne \
+        1,1 $inner.desc -fill both \
+        2,0 $inner.select_l -anchor ne \
+        2,1 $inner.select -fill both \
+        3,1 $inner.controls  -fill x
+    blt::table configure $inner r1 -height 1i
+    blt::table configure $inner r2 -pad 20
+    $popup configure \
+        -deactivatecommand [itcl::code $this Cancel] 
+
+    set inner [$popup component inner]
+    if {[$_resultset size] > 1} {
+        blt::table $inner \
+            2,0 $inner.select_l -anchor ne \
+            2,1 $inner.select -fill both 
+    } else {
+        blt::table forget $inner.select $inner.select_l
+    }
+    CheckSimsetDetails
+    update
+    # Activate the popup and call for the output.
+    $popup activate $itk_component(help) below
+    Cancel
+    tkwait variable [itcl::scope _done]
+    set doSave $_done
+    $popup deactivate 
+    return $doSave
+}
+
+
+itcl::body Rappture::Analyzer::ReadSimsetFile { fileName } {
+    if { [catch {
+        set f [open $fileName "r"]
+        set contents [read $f]
+        close $f
+        array set _saved $contents
+    } errs] != 0 } {
+        return 0
+    }
+    if { ![info exists _saved(Files)] } {
+        return 0
+    }
+    set saveDir [file dirname $fileName]
+    foreach file $_saved(Files) {
+        if { [file pathtype $file] == "relative" } {
+            set file [file join $saveDir $file]
+        }
+        if { ![file readable $file] } {
+            puts stderr "runfile $file isn't readable"
+            return 0
+        }
+    }
+    set _saved(FileName) $fileName
+    return 1
+}
+
+#
+# Run files can be either explicitly named with their absolute or
+# relative path.  If the path is relative it is assumed the parent
+# directory is relative to the simset file.
+#
+#   /my/path/to/myfile.sav 
+#   /my/path/to/myfile/runfiles...
+#
+itcl::body Rappture::Analyzer::LoadSimulations { files } {
+    set loadobjs {}
+    set saveDir [file dirname $_saved(FileName)]
+    foreach runfile $files {
+        if { [file pathtype $runfile] == "relative" } {
+            set runfile [file join $saveDir $runfile]
+        }
+        if { ![file exists $runfile] } {
+            puts stderr "can't find run: \"$runfile\""
+            continue
+        }
+        set status [catch {Rappture::library $runfile} result]
+        lappend loadobjs $result
+    }
+    clear
+    foreach runobj $loadobjs {
+        load $runobj
+    }
+    configure -notebookpage analyze
+    global win
+    $win.pager configure -nosim 1 
+    $win.pager current analyzer
+    $win.pager configure -nosim 0 
+}
+
+#
+# Delete selected simulation set.
+#
+itcl::body Rappture::Analyzer::SelectSimsetForDeletion {} {
+    if { [FindSimsetsForApp $_appName] == 0 } {
+        return
+    }
+    if { [GetSimset "delete"] } {
+        set saveDir [file dirname $_saved(FileName)]
+        file delete -force $saveDir
+    }
+}
+
+#
+# Find all .sav files for an application and load them into the tree.
+#
+itcl::body Rappture::Analyzer::FindSimsetsForApp { appName } {
+    if { $appName == "" } {
+        puts stderr "No application name found"
+        return 0
+    }
+    $_tree delete 0
+    foreach fileName [glob -nocomplain ~/data/saved/$appName/*/*.sav] {
+        if { [ReadSimsetFile $fileName] } {
+            if { $_revision > 0 && [info exists _saved(Revision)] &&
+                 $_revision != $_saved(Revision) } {
+                continue;               # Revision doesn't match.
+            }
+            $_tree insert 0 -label $_saved(Name) -data [array get _saved] 
+        }
+    }
+    return [$_tree degree 0]
+}
+
+#
+# Create dialog to select a simset from the currently available simsets.
+#
+itcl::body Rappture::Analyzer::GetSimset { name } {
+    set popup .selectsimset
+    if { [winfo exists $popup] } {
+        destroy $popup
+    }
+    # Create a popup for the print dialog
+    set title [string tolower $name]
+    Rappture::Balloon $popup -title "Select set of simulations to $title..."
+    set inner [$popup component inner]
+    
+    set tv $inner.tv
+    blt::treeview $inner.tv -tree $_tree \
+        -height 1i \
+        -width 5i \
+        -xscrollcommand [list $inner.xs set] \
+        -yscrollcommand [list $inner.ys set] \
+        -font "Arial 10"
+    scrollbar $inner.xs -orient horizontal -command "$tv xview"
+    scrollbar $inner.ys -orient vertical -command "$tv yview"
+    frame $inner.controls
+    
+    $tv column insert end "Name" "Description" "Date" "Creator"
+    $tv column configure treeView -hide yes 
+    blt::table $inner \
+        0,0 $inner.tv -fill both \
+        0,1 $inner.ys -fill y \
+        1,0 $inner.xs -fill x
+    blt::table configure $inner r* c* -resize none
+    blt::table configure $inner r0 c0 -resize both
+
+    button $inner.controls.cancel -text "Cancel" \
+        -command [itcl::code $this Cancel]
+    set title [string totitle $name]
+    button $inner.controls.save -text $title \
+        -command [itcl::code $this Ok]
+    blt::table $inner.controls \
+        0,0 $inner.controls.cancel \
+        0,1 $inner.controls.save
+    
+    blt::table $inner \
+        0,0 $inner.tv -fill both \
+        0,1 $inner.ys -fill y \
+        1,0 $inner.xs -fill x \
+        3,0 $inner.controls  -fill x -cspan 2
+    blt::table configure $inner r* c* -resize none
+    blt::table configure $inner r0 c0 -resize both
+    blt::table configure $inner r2 -height 0.1i
+    
+    $popup configure \
+        -deactivatecommand [itcl::code $this Cancel] 
+
+    $tv selection set [$_tree firstchild 0]
+    set inner [$popup component inner]
+    update
+    # Activate the popup and call for the output.
+    $popup activate $itk_component(help) below
+    Cancel
+    tkwait variable [itcl::scope _done]
+    set result $_done
+    $popup deactivate 
+    return $result
+}
+
+itcl::body Rappture::Analyzer::SelectSimsetForLoading {} {
+    if { [FindSimsetsForApp $_appName] == 0 } {
+        return
+    }
+    if { [GetSimset "load"] } {
+        LoadSimulations $_saved(Files)
+    }
+}
+
+itcl::body Rappture::Analyzer::reload { fileName } {
+    if { [catch {
+        ReadSimsetFile $fileName
+        if { [llength $_saved(Files)] > 0 } {
+            #StartSplashScreen
+            LoadSimulations $_saved(Files)
+            #HideSplashScreen
+        }
+    } errs] != 0 } {
+        puts stderr "can't load \"$fileName\": errs=$errs"
+    }
+}
+
+itcl::body Rappture::Analyzer::BuildQuestionDialog { popup } {
+    toplevel $popup -background grey92 -bd 2 -relief raised
+    wm withdraw $popup
+    wm overrideredirect $popup true
+    set inner $popup
+    # Create the print dialog widget and add it to the the balloon popup.
+    label $popup.title -text " " \
+        -padx 10 -pady 10 \
+        -background grey92 
+    button $popup.yes -text "Yes" \
+        -highlightthickness 0 \
+        -bd 2  \
+        -command [itcl::code $this Save] 
+    button $popup.no -text "No" \
+        -highlightthickness 0 \
+        -bd 2 \
+        -command [itcl::code $this Cancel] 
+    blt::table $popup \
+        0,0 $popup.title -cspan 2  -fill x -pady 4 \
+        1,0 $popup.yes -width { 0 1i .6i } -pady 4 \
+        1,1 $popup.no -width { 0 1i .6i }  -pady 4 
+    blt::table configure $popup  r2 -height 0.125i
+}
+
+itcl::body Rappture::Analyzer::Save {} {
+    set _done 1
+}
+
+itcl::body Rappture::Analyzer::OverwriteSaveFile {} {
+    set popup .question
+    if { ![winfo exists $popup] } {
+        BuildQuestionDialog $popup 
+    }
+    set text "Simulation set \"$_saved(Name)\" already exists. Overwrite?"
+    $popup.title configure -text $text 
+    $popup.yes configure -text "Save" 
+    $popup.no configure -text "Cancel" 
+    set main [winfo toplevel $itk_component(help)]
+    set pw [winfo reqwidth $popup]
+    set ph [winfo reqheight $popup]
+    set sw [winfo reqwidth $main]
+    set sh [winfo reqheight $main]
+    set rootx [winfo rootx $main]
+    set rooty [winfo rooty $main]
+    set x [expr $rootx + (($sw - $pw) / 2)]
+    set y [expr $rooty + (($sh - $ph) / 2)]
+    wm geometry $popup +$x+$y
+    wm deiconify $popup 
+    update
+    grab $popup 
+    # Activate the popup and call for the output.
+    Cancel
+    tkwait variable [itcl::scope _done]
+    set doSave $_done
+    grab release $popup 
+    destroy $popup 
+    return $doSave
+}
+
+itcl::body Rappture::Analyzer::InstallSharedFile { installdir file } {
+    set dst [file join $installdir [file tail $file]]
+    file copy -force $file $dst
+    file attributes $dst -permissions g+rw,o+r
+    return $dst
+}
+
+itcl::body Rappture::Analyzer::CreateSharedPath { path } {
+    set dir ""
+    foreach file [file split $path] {
+        set dir [file join $dir $file]
+        if { [file exists $dir] } {
+            if { ![file isdirectory $dir] } {
+                error "error in path \"$path\": \"$dir\" is not a directory."
+            }
+        } else {
+            file mkdir $dir 
+            file attributes $dir -permissions g+rwx,o+rx
+        }
+    }
+}
+
+itcl::body Rappture::Analyzer::ExportURL { appName installdir } {
+    set fileName [file join $installdir url.txt]
+    set name [file tail $installdir]
+    set f [open $fileName "w"]
+    puts $f "https://nanohub.org/tools/$appName/invoke?params=file(simset):$installdir/$name.sav\n"
+    close $f
+    file attributes $fileName -permissions g+rw,o+r
+    if { [file exists /usr/bin/exportfile] } {
+        set msgFile [file join $::Rappture::installdir export.html]
+        ExportFile $fileName $msgFile
+    }
+}
+
+itcl::body Rappture::Analyzer::ExportFile { src msgFile } {
+    set dstdir ~/.filexfer/exportfile
+    file mkdir $dstdir
+    set dst [file join $dstdir [file tail $src]]
+    if { [file exists $dst] } {
+        puts stderr "could be a problem: already waiting to export $dst"
+    }
+    file copy -force $src $dst
+    # Now export the file.
+    if { [catch {
+        global exportFileVar 
+        set exportFileVar 0;            # Kill any previous export.
+        set mesg "Select file to export to desktop/laptop"
+        update
+        set cmd "/usr/bin/exportfile --delete $dst --timeout 3 "
+        if { [file exists $msgFile] } { 
+            append cmd "--message $msgFile"
+        }
+        blt::bgexec exportFileVar /bin/sh -c $cmd &
+    } errs]  != 0 } {
+        global errorInfo
+        puts stderr "err: $errorInfo"
+        file delete -force $dst
+    }
+}
+

trunk/gui/scripts/loader.tcl

@@ -38 +38 @@
 
     private method SetDefaultValue { value }
+    private method EventuallySetDefaultValue { value }
 
     private variable _owner ""    ;# thing managing this control
@@ -246 +247 @@
     set str [string trim [$_owner xml get $path.default]]
     if { $str != "" } {
-        bind $itk_component(hull) <Map> [itcl::code $this SetDefaultValue $str]
+        EventuallySetDefaultValue $str
     }
 }
@@ -285 +286 @@
         $itk_component(combo) value $newval
         return $newval
-
     } elseif {[llength $args] != 0} {
         error "wrong # args: should be \"value ?-check? ?newval?\""
@@ -323 +323 @@
 }
 
-#
-# SetDefaultValue --
-#
-#       Sets the designated default value for the loader.  This must be done
-#       after the entire application is assembled, otherwise the default
-#       values set up by the loader will be overwritten by the various widgets
-#       themselves when they try to set their default values.
-#
-#       This is called from a  <Map> event to the loader (combobox).  This
-#       will get trigger the first time the loader is displayed.  The binding
-#       is then removed.
-#
 itcl::body Rappture::Loader::SetDefaultValue { value } {
-    after idle [itcl::code $this value $value]
-    # We're done. Remove the binding.
-    bind $itk_component(hull) <Map> {}
+    $itk_component(combo) value $value
+    _newValue
+}
+#
+#
+# EventuallySetDefaultValue --
+#
+#   Sets the designated default value for the loader.  This must be done
+#   after the entire application is assembled, otherwise the default values
+#   set up by the loader will be overwritten by the various widgets
+#   themselves when they try to set their default values.
+#
+itcl::body Rappture::Loader::EventuallySetDefaultValue { value } {
+    after 100 [itcl::code $this SetDefaultValue $value]
 }
 

trunk/gui/scripts/main.tcl

@@ -94 +94 @@
     list  -load ""
     value -input ""
+    value -simset ""
     value -nosim 0
 }
@@ -260 +261 @@
 
 #
-# Add a place for about/questions in the breadcrumbs area of this pager.
+# Add a place for menu button in the breadcrumbs area of this pager.
 #
 set app [string trim [$tool xml get tool.id]]
 set url [Rappture::Tool::resources -huburl]
-if {"" != $url && "" != $app} {
-    set f [$win.pager component breadcrumbarea]
-    frame $f.hubcntls
-    pack $f.hubcntls -side right -padx 4
-    label $f.hubcntls.icon -image [Rappture::icon ask] -highlightthickness 0
-    pack $f.hubcntls.icon -side left
-    button $f.hubcntls.about -text "About this tool" -command "
-        [list Rappture::filexfer::webpage $url/tools/$app]
-        Rappture::Logger::log help about
-    "
-    pack $f.hubcntls.about -side top -anchor w
-    button $f.hubcntls.questions -text Questions? -command "
-        [list Rappture::filexfer::webpage $url/resources/$app/questions]
-        Rappture::Logger::log help questions
-    "
-    pack $f.hubcntls.questions -side top -anchor w
-}
+set crumbs [$win.pager component breadcrumbarea]
+frame $crumbs.hubcntls
+pack $crumbs.hubcntls -side right -padx 4
+
+set m $crumbs.hubcntls.help.menu
+menubutton $crumbs.hubcntls.help \
+    -image [Rappture::icon hamburger_menu] \
+    -highlightthickness 0 \
+    -menu $m
+pack $crumbs.hubcntls.help -side top -anchor w
 
 #
@@ -339 +333 @@
 
 $tool notify add analyzer * [list $f.analyze reset]
+$f.analyze buildMenu $m $url $app
+
 
 # ----------------------------------------------------------------------
@@ -386 +382 @@
 
 # load previous xml runfiles
+update
 if {[llength $params(-load)] > 0} {
     foreach runobj $loadobjs {
@@ -398 +395 @@
     }
     $f.analyze configure -notebookpage analyze
+    $win.pager configure -nosim 1 
     $win.pager current analyzer
+    $win.pager configure -nosim 0 
+} elseif {$params(-simset) ne ""} {
+    $f.analyze reload $params(-simset)
 } elseif {$params(-input) ne ""} {
     $tool load $inputobj
@@ -407 +408 @@
 
 foreach path [array names ::Rappture::parameters] {
+    if { $path == "simset" } {
+        continue;                       # Don't consider file(simset)
+    }
     set fname $::Rappture::parameters($path)
-    if {[catch {
-          set fid [open $fname r]
-          set info [read $fid]
-          close $fid}] == 0} {
-
-        set w [$tool widgetfor $path]
-        if {$w ne ""} {
-            if {[catch {$w value [string trim $info]} result]} {
-                puts stderr "WARNING: bad tool parameter value for \"$path\""
-                puts stderr "  $result"
-            }
-        } else {
-            puts stderr "WARNING: can't find control for tool parameter: $path"
-        }
+    if { ![file exists $fname] } {
+        puts stderr "WARNING: tool parameters file \"$fname\" doesn't exist"
+        continue;                       # Can't find parameters file
+    }        
+    if { ![file readable $fname] } {
+        puts stderr "WARNING: can't read tool parameters file \"$fname\""
+        continue;                       # Can't read parameters file
+    }
+    set f [open $fname r]
+    set contents [read $f]
+    close $f
+    
+    set w [$tool widgetfor $path]
+    if { $w == "" } {
+        puts stderr "WARNING: can't find control for tool parameter: $path"
+        continue;                       # Can't find rappture control for path
+    }
+    if {[catch {$w value [string trim $info]} result]} {
+        puts stderr "WARNING: bad tool parameter value for \"$path\""
+        puts stderr "  $result"
     }
 }

trunk/gui/scripts/pager.tcl

@@ -67 +67 @@
     private variable _page2info      ;# maps page name => -frame,-title,-command
     private variable _current ""     ;# page currently shown
+    public variable nosim 0
 }
 
@@ -374 +375 @@
             # invoke it now.
             #
-            if {"" != $_current
-                  && [string length $_page2info($_current-command)] > 0} {
+            if {"" != $_current && !$nosim && 
+                  [string length $_page2info($_current-command)] > 0} {
                 uplevel #0 $_page2info($_current-command)
             }

trunk/lang/tcl/scripts/task.tcl

@@ -19 +19 @@
 
 itcl::class Rappture::Task {
+    private method CheckForCachedRunFile { driverFile }
+    private method CollectUQResults {}
+    private method ExecuteSimulationCommand { cmd }
+    private method GetCommand {}
+    private method GetDriverFile {}
+    private method GetSignal { signal }
+    private method GetSimulationCommand { driverFile }
+    private method GetUQErrors {}
+    private method GetUQSimulationCommand { driverFile }
+    private method GetUQTemplateFile {}
+    private method IsCacheable {}
+    private method LogCachedSimulationUsage {}
+    private method LogSimulationUsage {}
+    private method LogSubmittedSimulationUsage {}
+    private method SetCpuResourceLimit {}
+
     public variable logger ""
     public variable jobstats Rappture::Task::MiddlewareTime
@@ -35 +51 @@
     public method save {xmlobj {name ""}}
 
-    protected method _mkdir {dir}
-    protected method _output {data}
-    protected method _log {args}
-    protected method _build_submit_cmd {cmd tfile params_file}
-    protected method _get_params {varlist uq_type uq_args}
-    private method GetSignal { signal }
+    protected method OnOutput {data}
+    protected method Log {args}
+    protected method BuildSubmitCommand {cmd tfile params_file}
+    protected method GetParamsForUQ {}
 
     private variable _xmlobj ""      ;# XML object with inputs/outputs
     private variable _origxml ""     ;# copy of original XML (for reset)
-    private variable _lastrun ""     ;# name of last run file
     private variable _installdir ""  ;# installation directory for this tool
     private variable _outputcb ""    ;# callback for tool output
-    private common job               ;# array var used for blt::bgexec jobs
     private common jobnum 0          ;# counter for unique job number
-
+    private variable _uq
+    
+    private variable _job
+    
     # get global resources for this tool session
     public proc resources {{option ""}}
 
     public common _resources
-    public proc setAppName {name}   { set _resources(-appname) $name }
-    public proc setHubName {name}   { set _resources(-hubname) $name }
-    public proc setHubURL {name}    { set _resources(-huburl) $name }
-    public proc setSession {name}   { set _resources(-session) $name }
-    public proc setJobPrt {name}    { set _resources(-jobprotocol) $name }
-    public proc setResultDir {name} { set _resources(-resultdir) $name }
+    public proc setAppName {name}    { set _resources(-appname) $name }
+    public proc setHubName {name}    { set _resources(-hubname) $name }
+    public proc setHubURL {name}     { set _resources(-huburl) $name }
+    public proc setSession {name}    { set _resources(-session) $name }
+    public proc setJobPrt {name}     { set _resources(-jobprotocol) $name }
+    public proc setResultDir {name}  { set _resources(-resultdir) $name }
+    public proc setCacheHosts {name} { set _resources(-cachehosts) $name }
 
     # default method for -jobstats control
@@ -74 +90 @@
         session_token     Rappture::Task::setSession \
         job_protocol      Rappture::Task::setJobPrt \
-        results_directory Rappture::Task::setResultDir
+        results_directory Rappture::Task::setResultDir \
+        cache_hosts       Rappture::Task::setCacheHosts
 }
 
@@ -94 +111 @@
     }
     set _installdir $installdir
+    package require http
+    package require tls
+    http::register https 443 [list ::tls::socket -tls1 1]
 
     eval configure $args
@@ -137 +157 @@
     foreach {path val} $args {
         if {$path == "-uq_type"} {
-            set uq_type $val
+            set _uq(type) $val
         } elseif {$path == "-uq_args"} {
-            set uq_args $val
+            set _uq(args) $val
         }
     }
     #set varlist [$_xmlobj uq_get_vars]
     foreach {varlist num} [$_xmlobj uq_get_vars] break
-    return [Rappture::UQ ::#auto $varlist $num $uq_type $uq_args]
+    return [Rappture::UQ ::#auto $varlist $num $_uq(type) $_uq(args)]
 }
 
@@ -173 +193 @@
 
     #
-    # Make sure that we save the proper application name.
-    # Actually, the best place to get this information is
-    # straight from the "installtool" script, but just in
-    # case we have an older tool, we should insert the
+    # Make sure that we save the proper application name.  Actually, the
+    # best place to get this information is straight from the "installtool"
+    # script, but just in case we have an older tool, we should insert the
     # tool name from the resources config file.
     #
-    if {[info exists _resources(-appname)]
-          && $_resources(-appname) ne ""
-          && [$_xmlobj get tool.name] eq ""} {
+    if {[info exists _resources(-appname)] && $_resources(-appname) ne "" &&
+        [$_xmlobj get tool.name] eq ""} {
         $_xmlobj put tool.name $_resources(-appname)
     }
@@ -187 +205 @@
     # if there are any args, use them to override parameters
     set _outputcb ""
-    set uq_type ""
+    set _uq(type) ""
     foreach {path val} $args {
         if {$path == "-output"} {
             set _outputcb $val
         } elseif {$path == "-uq_type"} {
-            set uq_type $val
+            set _uq(type) $val
         } elseif {$path == "-uq_args"} {
-            set uq_args $val
+            set _uq(args) $val
         } else {
             $_xmlobj put $path.current $val
@@ -200 +218 @@
     }
 
-    foreach item {control output error} { set job($item) "" }
-
+    # Initialize job array variables
+    array set _job { 
+        control  ""
+        exitcode 0
+        mesg     ""
+        runfile  ""
+        stderr   ""
+        stdout   ""
+        success  0
+        xmlobj   ""
+    }
+
+    SetCpuResourceLimit 
+    set driverFile [GetDriverFile]
+    set cached 0
+    if { [IsCacheable] } {
+puts stderr "Cache checking: [time {
+        set cached [CheckForCachedRunFile $driverFile] 
+     } ]"
+puts stderr "checking cache=$cached"
+    }
+    if { !$cached } {
+        if { $_uq(type) != "" } {
+            set _uq(tfile) [GetUQTemplateFile]
+        }
+        if { $_uq(type) == "" } {
+            set cmd [GetSimulationCommand $driverFile]
+        } else {
+            set cmd [GetUQSimulationCommand $driverFile]
+        }
+        if { $cmd == "" } {
+            puts stderr "cmd is empty"
+            append mesg "There is no command specified by\n\n"
+            append mesg "    <command>\n"
+            append mesg "    </command>\n\n"
+            append mesg "in the tool.xml file."
+            return [list 1 $mesg]
+        }
+        Rappture::rusage mark
+        if { ![ExecuteSimulationCommand $cmd] } {
+            return [list 1 $_job(mesg)]
+        }
+        if { [resources -jobprotocol] == "submit" } {
+            LogSubmittedSimulationUsage
+        } else {
+            LogSimulationUsage
+        }
+    } else {
+        LogCachedSimulationUsage
+    }
+    if { $_job(success) } {
+        file delete -force -- $driverFile
+        Log run finished
+        return [list 0 $_job(xmlobj)]
+    } else {
+        # See if the job was aborted.
+        if {[regexp {^KILLED} $_job(control)]} {
+            Log run aborted
+            return [list 1 "ABORT"]
+        }
+        Log run failed [list 0 $_job(mesg)]
+        return [list 1 $_job(mesg)]
+    }
+}
+
+# ----------------------------------------------------------------------
+#  Turn the command string from tool.xml into the proper syntax to use
+#  with a submit parameter sweep with a temlate file.  Proper quoting
+# of the template file is necessary to prevent submit from being too smart
+# and converting it to a full pathname.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::BuildSubmitCommand {cmd tfile params_file} {
+    set quote_next 0
+    set newcmd "submit --progress submit --runName=puq -l -i @:$tfile -d $params_file"
+    set cmds [split $cmd " "]
+    for {set i 0} {$i < [llength $cmds]} {incr i} {
+        set arg [lindex $cmds $i]
+        if {$quote_next == 1} {
+            set nc [string range $arg 0 0]
+            if {$nc != "\""} {
+                set arg "\"\\\"$arg\\\"\""
+            }
+        }
+        if {$arg == "--eval"} {
+            set quote_next 1
+        } else {
+            set quote_next 0
+        }
+        if {$arg == "@driver"} {
+            set arg "\"\\\"$tfile\\\"\""
+        }
+        append newcmd " " $arg
+    }
+    regsub -all @driver $newcmd $tfile newcmd
+    return $newcmd
+}
+
+# ----------------------------------------------------------------------
+# USAGE: abort
+#
+# Clients use this during a "run" to abort the current job.
+# Kills the job and forces the "run" method to return.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::abort {} {
+    Log run abort
+    set _job(control) "abort"
+}
+
+# ----------------------------------------------------------------------
+# USAGE: reset
+#
+# Resets all input values to their defaults.  Sometimes used just
+# before a run to reset to a clean state.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::reset {} {
+    $_xmlobj copy "" from $_origxml ""
+    foreach path [Rappture::entities -as path $_xmlobj input] {
+        if {[$_xmlobj element -as type $path.default] ne ""} {
+            set defval [$_xmlobj get $path.default]
+            $_xmlobj put $path.current $defval
+        }
+    }
+}
+
+# ----------------------------------------------------------------------
+# USAGE: xml <subcommand> ?<arg> <arg> ...?
+# USAGE: xml object
+#
+# Used by clients to manipulate the underlying XML data for this
+# tool.  The <subcommand> can be any operation supported by a
+# Rappture::library object.  Clients can also request the XML object
+# directly by using the "object" subcommand.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::xml {args} {
+    if {"object" == $args} {
+        return $_xmlobj
+    }
+    return [eval $_xmlobj $args]
+}
+
+# ----------------------------------------------------------------------
+# USAGE: save <xmlobj> ?<filename>?
+#
+# Used by clients to save the contents of an <xmlobj> representing
+# a run out to the given file.  If <filename> is not specified, then
+# it uses the -resultsdir and other settings to do what Rappture
+# would normally do with the output.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::save {xmlobj {filename ""}} {
+    if {$filename eq ""} {
+
+        # If there's a results_directory defined in the resources file,
+        # then move the run.xml file there for storage.
+
+        set rdir ""
+        if {$resultdir eq "@default"} {
+            if {[info exists _resources(-resultdir)]} {
+                set rdir $_resources(-resultdir)
+            } else {
+                global rapptureInfo
+                set rdir $rapptureInfo(cwd)
+            }
+        } elseif {$resultdir ne ""} {
+            set rdir $resultdir
+        }
+
+        # use the runfile name generated by the last run
+        if {$_job(runfile) ne ""} {
+            set filename [file join $rdir $_job(runfile)]
+        } else {
+            set filename [file join $rdir run.xml]
+        }
+    }
+
+    # add any last-minute metadata
+    $xmlobj put output.time [clock format [clock seconds]]
+
+    $xmlobj put tool.version.rappture.version $::Rappture::version
+    $xmlobj put tool.version.rappture.revision $::Rappture::build
+    $xmlobj put output.filename $filename
+    $xmlobj put output.version $Rappture::version
+    
+    if {[info exists ::tcl_platform(user)]} {
+        $xmlobj put output.user $::tcl_platform(user)
+    }
+
+    # save the output
+    set rdir [file dirname $filename]
+    file mkdir $rdir
+
+    set fid [open $filename w]
+    puts $fid "<?xml version=\"1.0\"?>"
+    puts $fid [$xmlobj xml]
+    close $fid
+
+    Log output saved in $filename
+}
+
+# ----------------------------------------------------------------------
+# USAGE: OnOutput <data>
+#
+# Used internally to send each bit of output <data> coming from the
+# tool onto the caller, so the user can see progress.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::OnOutput {data} {
+    if {[string length $_outputcb] > 0} {
+        uplevel #0 $_outputcb [list $data]
+    }
+}
+
+# ----------------------------------------------------------------------
+# USAGE: Log <cmd> <arg> <arg> ...
+#
+# Used internally to log interesting events during the run.  If the
+# -logger option is set (to Rappture::Logger::log, or something like
+# that), then the arguments to this method are passed along to the
+# logger and written out to a log file.  Logging is off by default,
+# so this method does nothing unless -logger is set.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::Log {args} {
+    if {[string length $logger] > 0} {
+        uplevel #0 $logger [list $args]
+    }
+}
+
+# ----------------------------------------------------------------------
+# USAGE: MiddlewareTime <key> <value> ...
+#
+# Used as the default method for reporting job status information.
+# Implements the old HUBzero method of reporting job status info to
+# stderr, which can then be picked up by the tool session container.
+# Most tools use the "submit" command, which talks directly to a
+# database to log job information, so this isn't really needed.  But
+# it doesn't hurt to have this and it can be useful in some cases.
+# ----------------------------------------------------------------------
+itcl::body Rappture::Task::MiddlewareTime {args} {
+    set line "MiddlewareTime:"
+    foreach {key val} $args {
+        append line " $key=$val"
+    }
+    puts stderr $line
+}
+
+itcl::body Rappture::Task::IsCacheable {} {
+    if { ![info exists _resources(-cachehosts)] ||
+         $_resources(-cachehosts) == "" } {
+puts stderr cachehosts=[info exists _resources(-cachehosts)]
+        return 0
+    }
+if 0 {
+    set state [$_xmlobj get "tool.cache"]
+puts stderr "cache tag is \"$state\""
+    if { $state == "" } {
+        return 0
+    }
+} else {
+    set state 1 
+}
+    if { ![string is boolean $state] } {
+        return 0
+    }
+    return $state
+}
+
+#
+# Send the list of parameters to a python program so it can call PUQ
+# and get a CSV file containing the parameter values to use for the runs.
+itcl::body Rappture::Task::GetParamsForUQ {} {
+    set pid [pid]
+    # puts "puq.sh get_params $pid $_uq(varlist) $_uq(type) $_uq(args)"
+    if {[catch {
+        exec puq.sh get_params $pid $_uq(varlist) $_uq(type) $_uq(args)
+    } errs] != 0 } {
+        error "get_params.py failed: $errs\n[GetUQErrors]"
+    }
+    return "params${pid}.csv"
+}
+
+itcl::body Rappture::Task::SetCpuResourceLimit {} {
     # Set limits for cpu time
     set limit [$_xmlobj get tool.limits.cputime]
@@ -216 +511 @@
     }
     Rappture::rlimit set cputime $limit
-
-    # write out the driver.xml file for the tool
+}
+
+# Write out the driver.xml file for the tool
+itcl::body Rappture::Task::GetDriverFile {} {
     global rapptureInfo
-    set file [file join $rapptureInfo(cwd) "driver[pid].xml"]
-    set status [catch {
-        set fid [open $file w]
-        puts $fid "<?xml version=\"1.0\"?>"
-        puts $fid [$_xmlobj xml]
-        close $fid
-    } result]
-
-    if {$uq_type != ""} {
-        # Copy xml into a new file
-        set tfile "template[pid].xml"
-        set fid [open $tfile w]
-        puts $fid "<?xml version=\"1.0\"?>"
-        puts $fid [$_xmlobj xml]
-        close $fid
-
-        # Return a list of the UQ variables and their PDFs.
-        # Also turns $tfile into a template file.
-        set uq_varlist [lindex [$_xmlobj uq_get_vars $tfile] 0]
-    }
-
-
-    # execute the tool using the path from the tool description
-    if {$status == 0} {
-        set cmd [$_xmlobj get tool.command]
-        regsub -all @tool $cmd $_installdir cmd
-        set cmd [string trimleft $cmd " "]
-
-        if { $cmd == "" } {
-            puts stderr "cmd is empty"
-            return [list 1 "Command is empty.\n\nThere is no command specified by\n\n <command>\n </command>\n\nin the tool.xml file."]
-        }
-
-        if {$uq_type == ""} {
-            regsub -all @driver $cmd $file cmd
-
-            switch -glob -- [resources -jobprotocol] {
-                "submit*" {
-                    # if job_protocol is "submit", then use use submit command
-                    set cmd "submit --local $cmd"
-                }
-                "mx" {
-                    # metachory submission
-                    set cmd "mx $cmd"
-                }
-                "exec" {
-                    # default -- nothing special
-                }
+    set fileName [file join $rapptureInfo(cwd) "driver[pid].xml"]
+    if { [catch {
+        set f [open $fileName w]
+        puts $f "<?xml version=\"1.0\"?>"
+        puts $f [$_xmlobj xml]
+        close $f
+    } errs] != 0 } {
+        error "can't create driver file \"$fileName\": $errs"
+    }
+    return $fileName
+}
+
+itcl::body Rappture::Task::GetCommand { } {
+    set cmd [$_xmlobj get tool.command]
+    regsub -all @tool $cmd $_installdir cmd
+    set cmd [string trimleft $cmd " "]
+    return $cmd
+}
+
+itcl::body Rappture::Task::GetSimulationCommand { driverFile } {
+    set cmd [GetCommand]
+    if { $cmd == "" } {
+        return ""
+    }
+    regsub -all @driver $cmd $driverFile cmd
+
+    switch -glob -- [resources -jobprotocol] {
+        "submit*" {
+            # if job_protocol is "submit", then use use submit command
+            set cmd "submit --local $cmd"
+        }
+        "mx" {
+            # metachory submission
+            set cmd "mx $cmd"
+        }
+        "exec" {
+            # default -- nothing special
+        }
+    }
+    return $cmd
+}
+
+itcl::body Rappture::Task::GetUQSimulationCommand { driverFile } {
+    set cmd [GetCommand]
+    if { $cmd == "" } {
+        return ""
+    }
+    set paramsFile [GetParamsForUQ]
+    set cmd [BuildSubmitCommand $cmd $_uq(tfile) $paramsFile]
+    file delete -force puq
+    return $cmd
+}
+
+itcl::body Rappture::Task::GetUQTemplateFile {} {
+    global rapptureInfo
+    # Copy xml into a new file
+    set templateFile "template[pid].xml"
+    set f [open $templateFile w]
+    puts $f "<?xml version=\"1.0\"?>"
+    puts $f [$_xmlobj xml]
+    close $f
+
+    # Return a list of the UQ variables and their PDFs.
+    # Also turns $uq(tfile) into a template file.
+    set _uq(varlist) [lindex [$_xmlobj uq_get_vars $templateFile] 0]
+    set _uq(tfile) $templateFile
+    return $templateFile
+}
+
+itcl::body Rappture::Task::ExecuteSimulationCommand { cmd } {
+
+    set _job(runfile) ""
+    set _job(success) 0
+    set _job(exitcode) 0
+
+    # Step 1.  Write the command into the run file.
+    $_xmlobj put tool.execute $cmd
+
+    Log run started
+    Rappture::rusage mark
+
+    # Step 2.  Check if it is a special case "ECHO" command which always
+    #          succeeds.
+    if { [string compare -nocase -length 5 $cmd "ECHO "] == 0 } {
+        set _job(stdout) [string range $cmd 5 end]
+        set _job(success) 1
+        set _job(exitcode) 0
+        set _job(mesg) ""
+        return 1;                       # Success
+    } 
+
+    # Step 3. Execute the command, collecting its stdout and stderr.
+    catch {
+        eval blt::bgexec [list [itcl::scope _job(control)]] \
+            -keepnewline yes \
+            -killsignal  SIGTERM \
+            -onoutput    [list [itcl::code $this OnOutput]] \
+            -output      [list [itcl::scope _job(stdout)]] \
+            -error       [list [itcl::scope _job(stderr)]] \
+            $cmd
+    } result
+
+    # Step 4. Check the token and the exit code.
+    set logmesg $result
+    foreach { token _job(pid) _job(exitcode) mesg } $_job(control) break
+    if { $token == "EXITED" } {
+        if { $_job(exitcode) != 0 } {
+            # This means that the program exited normally but returned a
+            # non-zero exitcode.  Consider this an invalid result from the
+            # program.  Append the stderr from the program to the message.
+            if {$_job(exitcode) > 128} {
+                set logmesg "Program signaled: signal was [GetSignal $_job(exitcode)]"
+            } else { 
+                set logmesg "Program finished: non-zero exit code is $_job(exitcode)"
             }
-        } else {
-            set params_file [_get_params $uq_varlist $uq_type $uq_args]
-            set cmd [_build_submit_cmd $cmd $tfile $params_file]
-            file delete -force puq
-        }
-
-        $_xmlobj put tool.execute $cmd
-
-        # starting job...
-        set _lastrun ""
-        _log run started
-        Rappture::rusage mark
-
-        if {0 == [string compare -nocase -length 5 $cmd "ECHO "] } {
-            set status 0;
-            set job(output) [string range $cmd 5 end]
-        } else {
-            set status [catch {
-                set ::Rappture::Task::job(control) ""
-                eval blt::bgexec \
-                ::Rappture::Task::job(control) \
-                -keepnewline yes \
-                -killsignal SIGTERM \
-                -onoutput [list [itcl::code $this _output]] \
-                -output ::Rappture::Task::job(output) \
-                -error ::Rappture::Task::job(error) \
-                $cmd
-            } result]
-
-            if { $status != 0 } {
-                # We're here because the exec-ed program failed
-                set logmesg $result
-                if { $::Rappture::Task::job(control) ne "" } {
-                    foreach { token pid code mesg } \
-                    $::Rappture::Task::job(control) break
-                    if { $token == "EXITED" } {
-                       # This means that the program exited normally but
-                       # returned a non-zero exitcode.  Consider this an
-                       # invalid result from the program.  Append the stderr
-                       # from the program to the message.
-                       if {$code > 128} {
-                          set logmesg "Program signaled: signal was [GetSignal $code]"
-                       } else {
-                          set logmesg "Program finished: exit code is $code"
-                       }
-                       set result "$logmesg\n\n$::Rappture::Task::job(error)"
-                    } elseif { $token == "abort" }  {
-                        # The user pressed the abort button.
-                        set logmesg "Program terminated by user."
-                        set result "$logmesg\n\n$::Rappture::Task::job(output)"
-                    } else {
-                        # Abnormal termination
-                        set logmesg "Abnormal program termination: $mesg"
-                        set result "$logmesg\n\n$::Rappture::Task::job(output)"
-                    }
-                }
-                _log run failed [list $logmesg]
-                return [list $status $result]
-            }
-        }
-        # ...job is finished
-        array set times [Rappture::rusage measure]
-
-        if {[resources -jobprotocol] ne "submit"} {
-            set id [$_xmlobj get tool.id]
-            set vers [$_xmlobj get tool.version.application.revision]
-            set simulation simulation
-            if { $id ne "" && $vers ne "" } {
-                set pid [pid]
-                set simulation ${pid}_${id}_r${vers}
-            }
-
-            # need to save job info? then invoke the callback
-            if {[string length $jobstats] > 0} {
-                uplevel #0 $jobstats [list job [incr jobnum] \
-                event $simulation start $times(start) \
-                walltime $times(walltime) cputime $times(cputime) \
-                status $status]
-            }
-
-            #
-            # Scan through stderr channel and look for statements that
-            # represent grid jobs that were executed.  The statements
-            # look like this:
-            #
-            # MiddlewareTime: job=1 event=simulation start=3.001094 ...
-            #
-            set subjobs 0
-            while {[regexp -indices {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)} $job(error) match]} {
-                foreach {p0 p1} $match break
-                if {[string index $job(error) $p0] == "\n"} { incr p0 }
-
-                catch {unset data}
-                array set data {
-                    job 1
-                    event simulation
-                    start 0
-                    walltime 0
-                    cputime 0
-                    status 0
-                }
-                foreach arg [lrange [string range $job(error) $p0 $p1] 1 end] {
-                    foreach {key val} [split $arg =] break
-                    set data($key) $val
-                }
-                set data(job) [expr {$jobnum+$data(job)}]
-                set data(event) "subsimulation"
-                set data(start) [expr {$times(start)+$data(start)}]
-
-                set details ""
-                foreach key {job event start walltime cputime status} {
-                    # add required keys in a particular order
-                    lappend details $key $data($key)
-                    unset data($key)
-                }
-                foreach key [array names data] {
-                    # add anything else that the client gave -- venue, etc.
-                    lappend details $key $data($key)
-                }
-
-                if {[string length $jobstats] > 0} {
-                    uplevel #0 $jobstats $details
-                }
-
-                incr subjobs
-
-                # done -- remove this statement
-                set job(error) [string replace $job(error) $p0 $p1]
-            }
-            incr jobnum $subjobs
-        }
-
+            set _job(mesg) "$logmesg\n\n$_job(stderr)"
+            Log run failed [list $logmesg]
+            return 0;                   # Fail.
+        }
+        # Successful program termination with exit code of 0.
+    } elseif { $token == "abort" }  {
+        # The user pressed the abort button.
+        
+        set logmesg "Program terminated by user."
+        Log run failed [list $logmesg]
+        set _job(mesg) "$logmesg\n\n$_job(stdout)"
+        return 0;                       # Fail
     } else {
-        set job(error) "$result\n$errorInfo"
-    }
-    if {$status == 0} {
-        # file delete -force -- $file
-    }
-
-    # see if the job was aborted
-    if {[regexp {^KILLED} $job(control)]} {
-        _log run aborted
-        return [list 0 "ABORT"]
-    }
-
+        # Abnormal termination
+        
+        set logmesg "Abnormal program termination:"
+        Log run failed [list $logmesg]
+        set _job(mesg) "$logmesg\n\n$_job(stdout)"
+        return 0;                       # Fail
+    }
+    if { $_uq(type) != "" } {
+        CollectUQResults
+    }
+
+    # Step 5. Look in stdout for the name of the run file.
+    set pattern {=RAPPTURE-RUN=>([^\n]+)}
+    if {![regexp $pattern $_job(stdout) match fileName]} {
+        set _job(mesg) "Can't find result file in output.\n"
+        append _job(mesg) "Did you call Rappture::result in your simulator?"
+        return 0;                       # Fail
+    }
+    set _job(runfile) $fileName
+    set _job(success) 1
+    set _job(mesg) $_job(stdout)
+    return 1;                           # Success
+}
+
+itcl::body Rappture::Task::LogSimulationUsage {} {
+    array set times [Rappture::rusage measure]
+
+    set toolId     [$_xmlobj get tool.id]
+    set toolVers   [$_xmlobj get tool.version.application.revision]
+    set simulation "simulation"
+    if { $toolId ne "" && $toolVers ne "" } {
+        set simulation "[pid]_${toolId}_r${toolVers}"
+    }
+    
+    # Need to save job info? then invoke the callback
+    if { [string length $jobstats] > 0} {
+        lappend args \
+            "job"      [incr jobnum] \
+            "event"    $simulation \
+            "start"    $times(start) \
+            "walltime" $times(walltime) \
+            "cputime"  $times(cputime) \
+            "status"   $_job(exitcode)
+        uplevel #0 $jobstats $args 
+    }
+        
     #
-    # If successful, return the output, which should include
-    # a reference to the run.xml file containing results.
+    # Scan through stderr channel and look for statements that
+    # represent grid jobs that were executed.  The statements look
+    # like this:
     #
-
-    if {$status == 0} {
-        set result [string trim $job(output)]
-
-        if {$uq_type != ""} {
-            # UQ. Collect data from all jobs and put it in one xml run file.
-            file delete -force -- run_uq.xml
-            if {[catch {exec puq.sh analyze puq_[pid].hdf5} res]} {
-                set fp [open "uq_debug.err" r]
-                set rdata [read $fp]
-                close $fp
-                puts "PUQ analysis failed: $res\n$rdata"
-                error "UQ analysis failed: $res\n$rdata"
-            } else {
-                append result "\n" $res
-            }
-        }
-        if {[regexp {=RAPPTURE-RUN=>([^\n]+)} $result match file]} {
-            set _lastrun $file
-
-            set status [catch {Rappture::library $file} result]
-            if {$status == 0} {
-                # add cputime info to run.xml file
-                $result put output.walltime $times(walltime)
-                $result put output.cputime $times(cputime)
-                if {[info exists env(SESSION)]} {
-                    $result put output.session $env(SESSION)
-                }
-            } else {
-                global errorInfo
-                set result "$result\n$errorInfo"
-            }
-
-            file delete -force -- $file
-        } else {
-            set status 1
-            set result "Can't find result file in output.\nDid you call Rappture
-::result in your simulator?"
-        }
-    } elseif {$job(output) ne "" || $job(error) ne ""} {
-        set result [string trim "$job(output)\n$job(error)"]
-    }
-
-    # log final status for the run
-    if {$status == 0} {
-        _log run finished
+    # MiddlewareTime: job=1 event=simulation start=3.001094 ...
+    #
+    
+    set subjobs 0
+    set pattern {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)}
+    while { [regexp -indices $pattern $_job(stderr) match] } {
+        foreach {p0 p1} $match break
+        if { [string index $_job(stderr) $p0] == "\n" } {
+            incr p0
+        }
+        array unset data
+        array set data {
+            job 1
+            event simulation
+            start 0
+            walltime 0
+            cputime 0
+            status 0
+        }
+        foreach arg [lrange [string range $_job(stderr) $p0 $p1] 1 end] {
+            foreach {key val} [split $arg =] break
+            set data($key) $val
+        }
+        set data(job)   [expr { $jobnum + $data(job) }]
+        set data(event) "subsimulation"
+        set data(start) [expr { $times(start) + $data(start) }]
+        
+        set details ""
+        foreach key {job event start walltime cputime status} {
+            # Add required keys in a particular order
+            lappend details $key $data($key)
+            unset data($key)
+        }
+        foreach key [array names data] {
+            # Add anything else that the client gave -- venue, etc.
+            lappend details $key $data($key)
+        }
+        
+        if {[string length $jobstats] > 0} {
+            uplevel #0 $jobstats $details
+        }
+        
+        incr subjobs
+        
+        # Done -- remove this statement
+        set _job(stderr) [string replace $_job(stderr) $p0 $p1]
+    }
+    incr jobnum $subjobs
+
+    # Add cputime info to run.xml file
+    if { [catch {
+        Rappture::library $_job(runfile)
+    } xmlobj] != 0 } {
+        error "Can't create rappture library: $xmlobj"
+    }
+    $xmlobj put output.walltime $times(walltime)
+    $xmlobj put output.cputime $times(cputime)
+    global env
+    if {[info exists env(SESSION)]} {
+        $xmlobj put output.session $env(SESSION)
+    }
+    set _job(xmlobj) $xmlobj
+}
+
+itcl::body Rappture::Task::LogSubmittedSimulationUsage {} {
+    array set times [Rappture::rusage measure]
+
+    set toolId     [$_xmlobj get tool.id]
+    set toolVers   [$_xmlobj get tool.version.application.revision]
+    set simulation "simulation"
+    if { $toolId ne "" && $toolVers ne "" } {
+        set simulation "[pid]_${toolId}_r${toolVers}"
+    }
+    
+    # Need to save job info? then invoke the callback
+    if { [string length $jobstats] > 0} {
+        lappend args \
+            "job"      [incr jobnum] \
+            "event"    $simulation \
+            "start"    $times(start) \
+            "walltime" $times(walltime) \
+            "cputime"  $times(cputime) \
+            "status"   $_job(exitcode)
+        uplevel #0 $jobstats $args 
+    }
+        
+    #
+    # Scan through stderr channel and look for statements that
+    # represent grid jobs that were executed.  The statements look
+    # like this:
+    #
+    # MiddlewareTime: job=1 event=simulation start=3.001094 ...
+    #
+    
+    set subjobs 0
+    set pattern {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)}
+    while { [regexp -indices $pattern $_job(stderr) match] } {
+        foreach {p0 p1} $match break
+        if { [string index $_job(stderr) $p0] == "\n" } {
+            incr p0
+        }
+        array unset data
+        array set data {
+            job 1
+            event simulation
+            start 0
+            walltime 0
+            cputime 0
+            status 0
+        }
+        foreach arg [lrange [string range $_job(stderr) $p0 $p1] 1 end] {
+            foreach {key val} [split $arg =] break
+            set data($key) $val
+        }
+        set data(job)   [expr { $jobnum + $data(job) }]
+        set data(event) "subsimulation"
+        set data(start) [expr { $times(start) + $data(start) }]
+        
+        set details ""
+        foreach key {job event start walltime cputime status} {
+            # Add required keys in a particular order
+            lappend details $key $data($key)
+            unset data($key)
+        }
+        foreach key [array names data] {
+            # Add anything else that the client gave -- venue, etc.
+            lappend details $key $data($key)
+        }
+        
+        if {[string length $jobstats] > 0} {
+            uplevel #0 $jobstats $details
+        }
+        
+        incr subjobs
+        
+        # Done -- remove this statement
+        set _job(stderr) [string replace $_job(stderr) $p0 $p1]
+    }
+    incr jobnum $subjobs
+
+    # Add cputime info to run.xml file
+    if { [catch {
+        Rappture::library $_job(runfile)
+    } xmlobj] != 0 } {
+        error "Can't create rappture library: $xmlobj"
+    }
+    set _job(xmlobj) $xmlobj
+}
+
+itcl::body Rappture::Task::LogCachedSimulationUsage {} {
+    if { [catch {
+        Rappture::library $_job(runfile)
+    } xmlobj] != 0 } {
+        error "Can't create rappture library: $xmlobj"
+    }
+    # Get the session from runfile 
+    set session [$xmlobj get "output.session"]
+    if { [catch {exec submit --cache $session} result] != 0 } {
+       puts stderr "submit --cache failed: $result"
+    }
+    set _job(xmlobj) $xmlobj
+}
+
+
+itcl::body Rappture::Task::CheckForCachedRunFile { driverFile } {
+
+    # Read the driver file and collect its contents as the query.
+    set url http://$_resources(-cachehosts)/cache/request
+    set f [open $driverFile "r"]
+    set query [read $f]
+    close $f
+
+    # Make the query
+    if { [catch {
+        http::geturl $url -query $query -timeout 6000 -binary yes
+    } token] != 0 } {
+        puts stderr "error performing cache query: token=$token"
+        return 0
+    }
+    # If the code isn't 200, we'll assume it's a cache miss.
+    if { [http::ncode $token] != 200} {
+        return 0
+    }
+    # Get contents of the run file. 
+    set contents [http::data $token]
+    if { $contents == "" } {
+        return 0
+    }
+
+    # Create a new run.xml file and write the results into it. 
+    set secs [clock seconds]
+    set millisecs [expr [clock clicks -milliseconds] % 1000]
+    set timestamp [format %d%03d%03d $secs $millisecs 0]
+
+    global rapptureInfo
+    set fileName [file join $rapptureInfo(cwd) "run${timestamp}.xml"]
+    set f [open $fileName "w"]
+    puts $f $contents
+    close $f
+    set _job(runfile) $fileName
+    set _job(success) 1
+    set _job(stderr) "Loading cached results\n"
+    OnOutput "Loading cached results\n"
+    update
+    return 1
+}
+
+itcl::body Rappture::Task::GetUQErrors {} {
+    set contents {}
+    if { [file exists "uq_debug.err"] } {
+        set f [open "uq_debug.err" r]
+        set contents [read $f]
+        close $f
+    }
+    return $contents
+}
+
+# UQ. Collect data from all jobs and put it in one xml run file.
+itcl::body Rappture::Task::CollectUQResults {} {
+    file delete -force -- "run_uq.xml"
+    set hdfFile puq_[pid].hdf5
+    if { [catch {
+        exec puq.sh analyze $hdfFile
+    } results] != 0 } {
+        error "UQ analysis failed: $results\n[GetUQErrors]"
     } else {
-        _log run failed [list $result]
-    }
-
-    return [list $status $result]
-}
-
-# ----------------------------------------------------------------------
-#  Turn the command string from tool.xml into the proper syntax to use
-#  with a submit parameter sweep with a temlate file.  Proper quoting
-# of the template file is necessary to prevent submit from being too smart
-# and converting it to a full pathname.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::_build_submit_cmd {cmd tfile params_file} {
-    set quote_next 0
-    set newcmd "submit --progress submit --runName=puq -l -i @:$tfile -d $params_file"
-    set cmds [split $cmd " "]
-    for {set i 0} {$i < [llength $cmds]} {incr i} {
-        set arg [lindex $cmds $i]
-        if {$quote_next == 1} {
-            set nc [string range $arg 0 0]
-            if {$nc != "\""} {
-                set arg "\"\\\"$arg\\\"\""
-            }
-        }
-        if {$arg == "--eval"} {
-            set quote_next 1
-        } else {
-            set quote_next 0
-        }
-        if {$arg == "@driver"} {
-            set arg "\"\\\"$tfile\\\"\""
-        }
-        append newcmd " " $arg
-    }
-    regsub -all @driver $newcmd $tfile newcmd
-    return $newcmd
-}
-
-# ----------------------------------------------------------------------
-# USAGE: _mkdir <directory>
-#
-# Used internally to create the <directory> in the file system.
-# The parent directory is also created, as needed.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::_mkdir {dir} {
-    set parent [file dirname $dir]
-    if {$parent ne "." && $parent ne "/"} {
-        if {![file exists $parent]} {
-            _mkdir $parent
-        }
-    }
-    file mkdir $dir
-}
-
-
-# ----------------------------------------------------------------------
-# USAGE: abort
-#
-# Clients use this during a "run" to abort the current job.
-# Kills the job and forces the "run" method to return.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::abort {} {
-    _log run abort
-    set job(control) "abort"
-}
-
-# ----------------------------------------------------------------------
-# USAGE: reset
-#
-# Resets all input values to their defaults.  Sometimes used just
-# before a run to reset to a clean state.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::reset {} {
-    $_xmlobj copy "" from $_origxml ""
-    foreach path [Rappture::entities -as path $_xmlobj input] {
-        if {[$_xmlobj element -as type $path.default] ne ""} {
-            set defval [$_xmlobj get $path.default]
-            $_xmlobj put $path.current $defval
-        }
-    }
-}
-
-# ----------------------------------------------------------------------
-# USAGE: xml <subcommand> ?<arg> <arg> ...?
-# USAGE: xml object
-#
-# Used by clients to manipulate the underlying XML data for this
-# tool.  The <subcommand> can be any operation supported by a
-# Rappture::library object.  Clients can also request the XML object
-# directly by using the "object" subcommand.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::xml {args} {
-    if {"object" == $args} {
-        return $_xmlobj
-    }
-    return [eval $_xmlobj $args]
-}
-
-# ----------------------------------------------------------------------
-# USAGE: save <xmlobj> ?<filename>?
-#
-# Used by clients to save the contents of an <xmlobj> representing
-# a run out to the given file.  If <filename> is not specified, then
-# it uses the -resultsdir and other settings to do what Rappture
-# would normally do with the output.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::save {xmlobj {filename ""}} {
-    if {$filename eq ""} {
-        # if there's a results_directory defined in the resources
-        # file, then move the run.xml file there for storage
-        set rdir ""
-        if {$resultdir eq "@default"} {
-            if {[info exists _resources(-resultdir)]} {
-                set rdir $_resources(-resultdir)
-            } else {
-                global rapptureInfo
-                set rdir $rapptureInfo(cwd)
-            }
-        } elseif {$resultdir ne ""} {
-            set rdir $resultdir
-        }
-
-        # use the runfile name generated by the last run
-        if {$_lastrun ne ""} {
-            set filename [file join $rdir $_lastrun]
-        } else {
-            set filename [file join $rdir run.xml]
-        }
-    }
-
-    # add any last-minute metadata
-    $xmlobj put output.time [clock format [clock seconds]]
-
-    $xmlobj put tool.version.rappture.version $::Rappture::version
-    $xmlobj put tool.version.rappture.revision $::Rappture::build
-
-    if {[info exists ::tcl_platform(user)]} {
-        $xmlobj put output.user $::tcl_platform(user)
-    }
-
-    # save the output
-    set rdir [file dirname $filename]
-    if {![file exists $rdir]} {
-        _mkdir $rdir
-    }
-
-    set fid [open $filename w]
-    puts $fid "<?xml version=\"1.0\"?>"
-    puts $fid [$xmlobj xml]
-    close $fid
-
-    _log output saved in $filename
-}
-
-# ----------------------------------------------------------------------
-# USAGE: _output <data>
-#
-# Used internally to send each bit of output <data> coming from the
-# tool onto the caller, so the user can see progress.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::_output {data} {
-    if {[string length $_outputcb] > 0} {
-        uplevel #0 $_outputcb [list $data]
-    }
-}
-
-# ----------------------------------------------------------------------
-# USAGE: _log <cmd> <arg> <arg> ...
-#
-# Used internally to log interesting events during the run.  If the
-# -logger option is set (to Rappture::Logger::log, or something like
-# that), then the arguments to this method are passed along to the
-# logger and written out to a log file.  Logging is off by default,
-# so this method does nothing unless -logger is set.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::_log {args} {
-    if {[string length $logger] > 0} {
-        uplevel #0 $logger [list $args]
-    }
-}
-
-# ----------------------------------------------------------------------
-# USAGE: MiddlewareTime <key> <value> ...
-#
-# Used as the default method for reporting job status information.
-# Implements the old HUBzero method of reporting job status info to
-# stderr, which can then be picked up by the tool session container.
-# Most tools use the "submit" command, which talks directly to a
-# database to log job information, so this isn't really needed.  But
-# it doesn't hurt to have this and it can be useful in some cases.
-# ----------------------------------------------------------------------
-itcl::body Rappture::Task::MiddlewareTime {args} {
-    set line "MiddlewareTime:"
-    foreach {key val} $args {
-        append line " $key=$val"
-    }
-    puts stderr $line
-}
-
-
-#
-# Send the list of parameters to a python program so it can call PUQ
-# and get a CSV file containing the parameter values to use for the runs.
-itcl::body Rappture::Task::_get_params {varlist uq_type uq_args} {
-    set pid [pid]
-    # puts "puq.sh get_params $pid $varlist $uq_type $uq_args"
-    if { [catch {
-        exec puq.sh get_params $pid $varlist $uq_type $uq_args
-    } errs] != 0 } {
-        set contents {}
-        if { [file exists "uq_debug.err"] } {
-            set fp [open "uq_debug.err" r]
-            set contents [read $fp]
-            close $fp
-        }
-        puts "get_params.py failed: $errs\n$contents"
-        error "get_params.py failed: $errs\n$contents"
-    }
-    return params[pid].csv
-}
+        set _job(stdout) $results
+    }
+}

trunk/src/core/RpLibrary.cc

@@ -1791 +1791 @@
 
     // check for binary data
-    // FIXME: I've already appended a NUL-byte of this assuming that
+    // FIXME: I've already appended a NUL-byte to this assuming that
     //        it's a ASCII string. This test must come before.
     if (Rappture::encoding::isBinary(value.c_str(), value.length())) {
@@ -2047 +2047 @@
         return *this;
     }
-    if (compress == RPLIB_COMPRESS) {
+    if ((compress == RPLIB_COMPRESS) ||
+        (Rappture::encoding::isBinary(fileBuf.bytes(), fileBuf.size()))) {      
         putData(path, fileBuf.bytes(), fileBuf.size(), append);
     } else {