Changeset 4961 for trunk


Ignore:
Timestamp:
Jan 29, 2015 6:55:17 PM (5 years ago)
Author:
mmc
Message:

Fixed the way that Rappture handles tool parameters. When Rappture starts
up, it looks for the TOOL_PARAMETERS environment variable and loads values
from that file. Any "file" parameters are used to load driver files, run
files, or data into controls. See http://rappture.org/wiki/RapptureApi
for details.

Location:
trunk/gui
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/gui/apps/launcher.tcl

    r4834 r4961  
    2727set mainscript ""
    2828set alist ""
     29set loadlist ""
    2930set toolxml ""
     31
     32# ----------------------------------------------------------------------
     33#  Look for parameters passed into the tool session.  If there are
     34#  any "file" parameters, they indicate files that should be loaded
     35#  for browsing or executed to get results:
     36#
     37#    file(load):/path/to/run.xml
     38#    file(execute):/path/to/driver.xml
     39# ----------------------------------------------------------------------
     40set params(opt) ""
     41set params(load) ""
     42set params(execute) ""
     43set params(input) ""
     44
     45if {[info exists env(TOOL_PARAMETERS)]} {
     46    # if we can't find the file, wait a little
     47    set ntries 25
     48    while {$ntries > 0 && ![file exists $env(TOOL_PARAMETERS)]} {
     49        after 200
     50        incr ntries -1
     51    }
     52
     53    if {![file exists $env(TOOL_PARAMETERS)]} {
     54        # still no file after all that? then skip parameters
     55        puts stderr "WARNING: can't read tool parameters in file \"$env(TOOL_PARAMETERS)\"\nFile not found."
     56
     57    } elseif {[catch {
     58        # read the file and parse the contents
     59        set fid [open $env(TOOL_PARAMETERS) r]
     60        set info [read $fid]
     61        close $fid
     62    } result] != 0} {
     63        puts stderr "WARNING: can't read tool parameters in file \"$env(TOOL_PARAMETERS)\"\n$result"
     64
     65    } else {
     66        # parse the contents of the tool parameter file
     67        foreach line [split $info \n] {
     68            set line [string trim $line]
     69            if {$line eq "" || [regexp {^#} $line]} {
     70                continue
     71            }
     72
     73            if {[regexp {^([a-zA-Z]+)(\(into\:)(.+)\)\:(.+)$} $line match type name path value]
     74                || [regexp {^([a-zA-Z]+)(\([^)]+\))?\:(.+)} $line match type name value]} {
     75                if {$type eq "file"} {
     76                    switch -exact -- $name {
     77                        "(load)" - "" {
     78                            lappend params(load) $value
     79                            set params(opt) "-load"
     80                        }
     81                        "(execute)" {
     82                            set params(execute) $value
     83                            set params(opt) "-execute"
     84                        }
     85                        "(input)" {
     86                            set params(input) $value
     87                            set params(opt) "-input"
     88                        }
     89                        "(into:" {
     90                            namespace eval ::Rappture { # forward decl }
     91                            set ::Rappture::parameters($path) $value
     92                        }
     93                        default {
     94                            puts stderr "WARNING: directive $name not recognized for file parameter \"$value\""
     95                        }
     96                    }
     97                }
     98            }
     99        }
     100    }
     101}
    30102
    31103# scan through the arguments and look for the function
     
    81153                lappend alist -tool $toolxml
    82154            }
    83             -tool - -testdir - -nosim {
     155            -testdir - -nosim {
    84156                lappend alist $opt [lindex $argv 0]
    85157                set argv [lrange $argv 1 end]
     
    93165            }
    94166            -load {
    95                 lappend alist $opt
    96167                while { [llength $argv] > 0 } {
    97168                    set val [lindex $argv 0]
     
    99170                        break
    100171                    }
    101                     lappend alist $val
     172                    lappend loadlist $val
    102173                    set argv [lrange $argv 1 end]
    103174                }
     
    115186}
    116187
    117 # If no arguments, assume that it's the -run option
     188# If no arguments, check to see if there are any tool parameters.
     189# If not, then assume that it's the -run option.
    118190if {$mainscript eq ""} {
    119     package require RapptureGUI
    120     set guidir $RapptureGUI::library
    121     set mainscript [file join $guidir scripts main.tcl]
    122     set reqpkgs Tk
     191    switch -- $params(opt) {
     192        -load {
     193            # add tool parameters to the end of any files given on cmd line
     194            set loadlist [concat $loadlist $params(load)]
     195            set alist [concat $alist -load $loadlist]
     196
     197            package require RapptureGUI
     198            set guidir $RapptureGUI::library
     199            set mainscript [file join $guidir scripts main.tcl]
     200            set reqpkgs Tk
     201        }
     202        -execute {
     203            if {[llength $params(execute)] != 1} {
     204                puts stderr "ERROR: wrong number of (execute) files in TOOL_PARAMETERS (should be only 1)"
     205                exit 1
     206            }
     207            set driverxml [lindex $params(execute) 0]
     208            if {![file readable $driverxml]} {
     209                puts stderr "error: driver file \"$driverxml\" not found"
     210                exit 1
     211            }
     212            set dir [file dirname [info script]]
     213            set mainscript [file join $dir execute.tcl]
     214            set reqpkgs ""
     215        }
     216        "" - "-input" {
     217            package require RapptureGUI
     218            set guidir $RapptureGUI::library
     219            set mainscript [file join $guidir scripts main.tcl]
     220            set reqpkgs Tk
     221
     222            # finalize the -input argument for "rappture -run"
     223            if {$params(input) ne ""} {
     224                if {![file readable $params(input)]} {
     225                    puts stderr "error: driver file \"$params(input)\" not found"
     226                    exit 1
     227                }
     228                set alist [concat $alist -input $params(input)]
     229            }
     230
     231            # finalize any pending -load arguments for "rappture -run"
     232            if {[llength $loadlist] > 0} {
     233                set alist [concat $alist -load $loadlist]
     234            }
     235        }
     236        default {
     237            puts stderr "internal error: funny action \"$params(opt)\" inferred from TOOL_PARAMETERS"
     238            exit 1
     239        }
     240    }
     241} else {
     242    # finalize any pending -load arguments for "rappture -run"
     243    if {[llength $loadlist] > 0} {
     244        set alist [concat $alist -load $loadlist]
     245    }
    123246}
    124247
  • trunk/gui/scripts/main.tcl

    r3700 r4961  
    9393    value -tool tool.xml
    9494    list  -load ""
     95    value -input ""
    9596    value -nosim 0
    96 }
    97 
    98 proc ReadToolParameters { numTries } {
    99     incr numTries -1
    100     if { $numTries < 0 } {
    101         return
    102     }
    103     global env
    104     set paramsFile $env(TOOL_PARAMETERS)
    105     if { ![file readable $paramsFile] } {
    106         after 500 ReadToolParmeters $numTries
    107         return
    108     }
    109     catch {
    110         set f [open $paramsFile "r"]
    111         set contents [read $f]
    112         close $f
    113         set pattern {^file\((.*)\):(.*)$}
    114         foreach line [split $contents "\n"] {
    115             if { [regexp $pattern $line match path rest] } {
    116                 set ::Rappture::parameters($path) $rest
    117             }
    118         }
    119     }
    120 }
    121 
    122 if { [info exists env(TOOL_PARAMETERS)] } {
    123     ReadToolParameters 10
    12497}
    12598
     
    132105    set status [catch {Rappture::library $runfile} result]
    133106    lappend loadobjs $result
     107}
     108
     109set inputobj {}
     110if {$params(-input) ne ""} {
     111    if {![file exists $params(-input)]} {
     112        puts stderr "can't find input file: \"$params(-input)\""
     113        exit 1
     114    }
     115    if {[catch {Rappture::library $params(-input)} result] == 0} {
     116        set inputobj $result
     117    }
    134118}
    135119
     
    143127    # run.xml files they are loading.
    144128    set pseudotool ""
    145     if {0 == [llength $loadobjs]} {
     129    if {[llength $loadobjs] == 0 && $inputobj eq ""} {
    146130        puts stderr "can't find tool \"$params(-tool)\""
    147131        exit 1
     
    151135    # if there are loaders or notes, they will still need
    152136    # examples/ and docs/ dirs from the install location
    153     foreach runobj $loadobjs {
     137    set check [concat $loadobjs $inputobj]
     138    foreach runobj $check {
    154139        set tdir \
    155140            [string trim [$runobj get tool.version.application.directory(tool)]]
     
    374359
    375360# load previous xml runfiles
    376 if {0 != [llength $params(-load)]} {
     361if {[llength $params(-load)] > 0} {
    377362    foreach runobj $loadobjs {
    378         # this doesn't seem to work with loaders
    379         # loaders seem to get their value after this point
    380         # may need to tell loader elements to update its value
    381         $tool load $runobj
    382363        $f.analyze load $runobj
    383364    }
     365    # load the inputs for the very last run
     366    $tool load $runobj
     367
    384368    # don't need simulate button if we cannot simulate
    385369    if {$params(-nosim)} {
     
    388372    $f.analyze configure -notebookpage analyze
    389373    $win.pager current analyzer
     374} elseif {$params(-input) ne ""} {
     375    $tool load $inputobj
     376}
     377
     378# let components (loaders) settle after the newly loaded runs
     379update
     380
     381foreach path [array names ::Rappture::parameters] {
     382    set fname $::Rappture::parameters($path)
     383    if {[catch {
     384          set fid [open $fname r]
     385          set info [read $fid]
     386          close $fid}] == 0} {
     387
     388        set w [$tool widgetfor $path]
     389        if {$w ne ""} {
     390            if {[catch {$w value [string trim $info]} result]} {
     391                puts stderr "WARNING: bad tool parameter value for \"$path\""
     392                puts stderr "  $result"
     393            }
     394        } else {
     395            puts stderr "WARNING: can't find control for tool parameter: $path"
     396        }
     397    }
    390398}
    391399
  • trunk/gui/scripts/textentry.tcl

    r4276 r4961  
    106106    # the string alone.
    107107    set str [string trim [$_owner xml get $path.default]]
    108     if { [info exists ::Rappture::parameters($path.default)] } {
    109         set fileName $::Rappture::parameters($path.default)
    110         catch {
    111             set f [open $fileName "r"]
    112             set contents [read $f]
    113             close $f
    114             set str $contents
    115         }
    116     }
    117108    if {"" != $str} {
    118109        value $str
Note: See TracChangeset for help on using the changeset viewer.