Parent Directory
| 
Revision Log
Revision 1.29 - (view) (download) (as text)
| 1 : | olson | 1.1 | # |
| 2 : | olson | 1.28 | # Copyright (c) 2003-2006 University of Chicago and Fellowship |
| 3 : | # for Interpretations of Genomes. All Rights Reserved. | ||
| 4 : | # | ||
| 5 : | # This file is part of the SEED Toolkit. | ||
| 6 : | # | ||
| 7 : | # The SEED Toolkit is free software. You can redistribute | ||
| 8 : | # it and/or modify it under the terms of the SEED Toolkit | ||
| 9 : | # Public License. | ||
| 10 : | # | ||
| 11 : | # You should have received a copy of the SEED Toolkit Public License | ||
| 12 : | # along with this program; if not write to the University of Chicago | ||
| 13 : | # at info@ci.uchicago.edu or the Fellowship for Interpretation of | ||
| 14 : | # Genomes at veronika@thefig.info or download a copy from | ||
| 15 : | # http://www.theseed.org/LICENSE.TXT. | ||
| 16 : | # | ||
| 17 : | |||
| 18 : | # | ||
| 19 : | olson | 1.1 | # FIG bootstrap script. |
| 20 : | # | ||
| 21 : | # Control is passed here from the toplevel configure (or dists/releases/install depending | ||
| 22 : | # on how far we've gotten in the process). | ||
| 23 : | # | ||
| 24 : | # The configure has set the following environment variables for our use: | ||
| 25 : | # | ||
| 26 : | # FIG_HOME Root of the FIGdisk tree we're setting up | ||
| 27 : | # FIGCONFIG_ENV Name of the environment we're configuring for | ||
| 28 : | # FIGCONFIG_ENV_DIR Directory in which the binary install tree for $FIGCONFIG_ENV lives | ||
| 29 : | # FIGCONFIG_RELEASE Release number we're configuring | ||
| 30 : | # FIGCONFIG_RELEASE_DIR Directory in which that release lives | ||
| 31 : | # | ||
| 32 : | # Important note: perl system libraries may not be available when this | ||
| 33 : | # script is running, if the FIGCONFIG_ENV_DIR is different than it was | ||
| 34 : | # when the binaries were created. Part of the task of this | ||
| 35 : | # script is to recognize this case and configure the process | ||
| 36 : | # environment correctly so that the post-install process as | ||
| 37 : | # handled by the Makefiles can use perl properly, without concern for paths. | ||
| 38 : | # | ||
| 39 : | |||
| 40 : | # | ||
| 41 : | # Look into the FIGCONFIG_ENV_DIR for the PREFIX that this | ||
| 42 : | # environment was compiled on. If that directory is different | ||
| 43 : | # than the one we're currently using, rewrite @INC accordingly. | ||
| 44 : | # | ||
| 45 : | # We put this into a BEGIN block so that we can later use "use" | ||
| 46 : | # without worrying about paths. | ||
| 47 : | # | ||
| 48 : | # We also set the $perlenv_override to true if we've done this, | ||
| 49 : | # so we can insert these fixes into the perl tool header. | ||
| 50 : | # | ||
| 51 : | |||
| 52 : | BEGIN { | ||
| 53 : | |||
| 54 : | olson | 1.3 | print "Here in the perl bootstrap. inc is:\n" . join("\n", @INC), "\n"; |
| 55 : | olson | 1.1 | |
| 56 : | parrello | 1.29 | my ($my_prefix, $prefix, $inc, @newInc); |
| 57 : | olson | 1.1 | |
| 58 : | $my_prefix = $ENV{FIGCONFIG_ENV_DIR}; | ||
| 59 : | open(P, "<$my_prefix/PREFIX"); | ||
| 60 : | $prefix = <P>; | ||
| 61 : | chomp $prefix; | ||
| 62 : | |||
| 63 : | |||
| 64 : | # print "Prefix is $prefix myprefix=$my_prefix\n"; | ||
| 65 : | |||
| 66 : | if ($prefix ne $my_prefix) | ||
| 67 : | { | ||
| 68 : | @newInc = (); | ||
| 69 : | for $inc (@INC) | ||
| 70 : | { | ||
| 71 : | $inc =~ s,^$prefix,$my_prefix,; | ||
| 72 : | push(@newInc, $inc); | ||
| 73 : | } | ||
| 74 : | |||
| 75 : | $::perlenv_override = 1; | ||
| 76 : | olson | 1.3 | @INC = @newInc; |
| 77 : | olson | 1.1 | } |
| 78 : | } | ||
| 79 : | |||
| 80 : | |||
| 81 : | use FileHandle; | ||
| 82 : | use strict; | ||
| 83 : | |||
| 84 : | # | ||
| 85 : | # Environment definition | ||
| 86 : | # | ||
| 87 : | # This list contains triples | ||
| 88 : | # ($name, $value, $appendFlag). $name is the name of the | ||
| 89 : | # variable; $value is the value to set, and $appendFlag | ||
| 90 : | # is nonzero if we need to append this value to an existing | ||
| 91 : | # environment variable. | ||
| 92 : | # | ||
| 93 : | |||
| 94 : | our $Env = []; | ||
| 95 : | |||
| 96 : | # | ||
| 97 : | # FIG configuration information. | ||
| 98 : | # This list contains tuples [$name, $value, $quote] | ||
| 99 : | # which are to be set in the FIG_Config modules for | ||
| 100 : | # both python and perl. $quote is 1 for things that need | ||
| 101 : | # to be quoted, 0 otherwise. | ||
| 102 : | # | ||
| 103 : | our $Config = []; | ||
| 104 : | |||
| 105 : | # | ||
| 106 : | # Other key/value pairs of stuff we may need to pass | ||
| 107 : | # to and from the environment-specific configuration modules. | ||
| 108 : | # | ||
| 109 : | # Known keys: | ||
| 110 : | # | ||
| 111 : | # pythonpath | ||
| 112 : | # | ||
| 113 : | |||
| 114 : | our $OtherConfig = {}; | ||
| 115 : | |||
| 116 : | # | ||
| 117 : | # Cache values of the various places we may be installing things. | ||
| 118 : | # | ||
| 119 : | |||
| 120 : | our $fig_disk = $ENV{FIG_HOME}; | ||
| 121 : | our $env_name = $ENV{FIGCONFIG_ENV}; | ||
| 122 : | olson | 1.7 | our $env_dir = "$ENV{FIGCONFIG_ENV_DIR}"; |
| 123 : | olson | 1.1 | our $env_bin = "$ENV{FIGCONFIG_ENV_DIR}/bin"; |
| 124 : | our $env_lib = "$ENV{FIGCONFIG_ENV_DIR}/lib"; | ||
| 125 : | olson | 1.2 | # |
| 126 : | # We are moving to use a symlink in dist/releases/current for these. | ||
| 127 : | # This symlink is managed by switch_to_release. | ||
| 128 : | # | ||
| 129 : | #our $release_bin = "$ENV{FIGCONFIG_RELEASE_DIR}/bin/$ENV{FIGCONFIG_ENV}"; | ||
| 130 : | #our $release_lib = "$ENV{FIGCONFIG_RELEASE_DIR}/lib/$ENV{FIGCONFIG_ENV}"; | ||
| 131 : | |||
| 132 : | olson | 1.8 | our $release_bin = "$fig_disk/dist/releases/current/$ENV{FIGCONFIG_ENV}/bin"; |
| 133 : | our $release_lib = "$fig_disk/dist/releases/current/$ENV{FIGCONFIG_ENV}/lib"; | ||
| 134 : | olson | 1.2 | |
| 135 : | our $fig_bin = "$fig_disk/FIG/bin"; | ||
| 136 : | olson | 1.1 | |
| 137 : | # | ||
| 138 : | # Location of start/stop servers scripts. | ||
| 139 : | # | ||
| 140 : | our $start_servers = "$fig_disk/bin/start-servers"; | ||
| 141 : | our $stop_servers = "$fig_disk/bin/stop-servers"; | ||
| 142 : | |||
| 143 : | sub configure_std_fig_environment | ||
| 144 : | { | ||
| 145 : | # | ||
| 146 : | # Populate the Config with the usual stuff we need in FIG_Config.pm. | ||
| 147 : | # | ||
| 148 : | |||
| 149 : | my $fig = "$fig_disk/FIG"; | ||
| 150 : | my $data = "$fig/Data"; | ||
| 151 : | olson | 1.21 | my $sproutData = "$fig/SproutData"; |
| 152 : | olson | 1.1 | |
| 153 : | my $hostname = `hostname`; | ||
| 154 : | chomp $hostname; | ||
| 155 : | |||
| 156 : | push(@$Config, ["fig_disk", $fig_disk, 1]); | ||
| 157 : | olson | 1.6 | push(@$Config, ["blastmat", "$fig_disk/BLASTMAT", 1]); |
| 158 : | olson | 1.1 | push(@$Config, ["fig", $fig, 1]); |
| 159 : | olson | 1.2 | push(@$Config, ["bin", $fig_bin, 1]); |
| 160 : | olson | 1.1 | push(@$Config, ["ext_bin", $env_bin, 1]); |
| 161 : | olson | 1.18 | push(@$Config, ["common_runtime", $env_dir, 1]); |
| 162 : | push(@$Config, ["arch", $ENV{FIGCONFIG_ENV}, 1]); | ||
| 163 : | olson | 1.22 | push(@$Config, ["var", "$fig/var", 1]); |
| 164 : | olson | 1.1 | push(@$Config, ["data", $data, 1]); |
| 165 : | push(@$Config, ["global", "$data/Global", 1]); | ||
| 166 : | push(@$Config, ["organisms", "$data/Organisms", 1]); | ||
| 167 : | push(@$Config, ["RC", "$fig_disk/FIG/ResolutionCenter", 1]); | ||
| 168 : | push(@$Config, ["NR", "$fig_disk/FIG/NR", 1]); | ||
| 169 : | push(@$Config, ["temp", "$fig_disk/FIG/Tmp", 1]); | ||
| 170 : | olson | 1.21 | push(@$Config, ["sproutData", $sproutData, 1]); |
| 171 : | olson | 1.11 | |
| 172 : | my $sandbox; | ||
| 173 : | if ($ENV{FIGCONFIG_SANDBOX}) | ||
| 174 : | { | ||
| 175 : | $sandbox = "/$ENV{FIGCONFIG_SANDBOX}"; | ||
| 176 : | } | ||
| 177 : | |||
| 178 : | push(@$Config, ["temp_url", "http://$hostname$sandbox/FIG-Tmp", 1]); | ||
| 179 : | push(@$Config, ["cgi_url", "http://$hostname$sandbox/FIG", 1]); | ||
| 180 : | golsen | 1.9 | |
| 181 : | # | ||
| 182 : | # Add values for a relative base href of temp and CGI pages. The latter | ||
| 183 : | # is used by HHTP.pm to write common page start. It would make the most | ||
| 184 : | # sense to derive the above 2 values from these. -- GJO | ||
| 185 : | # | ||
| 186 : | |||
| 187 : | olson | 1.11 | push(@$Config, ["temp_base", "$sandbox/FIG-Tmp/", 1]); |
| 188 : | push(@$Config, ["cgi_base", "$sandbox/FIG/", 1]); | ||
| 189 : | parrello | 1.29 | |
| 190 : | olson | 1.1 | } |
| 191 : | |||
| 192 : | sub compute_environment | ||
| 193 : | { | ||
| 194 : | # | ||
| 195 : | # ReleaseTools configuration. | ||
| 196 : | # | ||
| 197 : | |||
| 198 : | push(@$Env, ["RTROOT", $ENV{FIG_HOME}, 0]); | ||
| 199 : | push(@$Env, ["RTDIST", "\$RTROOT/dist", 0]); | ||
| 200 : | olson | 1.23 | push(@$Env, ["RTSITECONFIGDIR", "\$RTROOT/config", 0]); |
| 201 : | olson | 1.1 | push(@$Env, ["RTARCH", $ENV{FIGCONFIG_ENV}, 0]); |
| 202 : | olson | 1.2 | push(@$Env, ["RTCURRENT", "`cat \$RTROOT/CURRENT_RELEASE`", 0]); |
| 203 : | olson | 1.1 | push(@$Env, ["FIG_HOME", $ENV{FIG_HOME}, 0]); |
| 204 : | |||
| 205 : | push(@$Env, ["BLASTMAT", "$ENV{FIG_HOME}/BLASTMAT", 0]); | ||
| 206 : | |||
| 207 : | # | ||
| 208 : | # Determine the path to use. | ||
| 209 : | # | ||
| 210 : | # This includes the path into the particular release we're configuring for, | ||
| 211 : | # and to the environment's bin directory. | ||
| 212 : | # | ||
| 213 : | |||
| 214 : | my @path = (); | ||
| 215 : | olson | 1.24 | push(@path, $fig_bin); |
| 216 : | olson | 1.1 | push(@path, $env_bin); |
| 217 : | push(@path, "$fig_disk/bin"); | ||
| 218 : | |||
| 219 : | push(@$Env, ["PATH", join(":", @path), 1]); | ||
| 220 : | |||
| 221 : | olson | 1.26 | # |
| 222 : | # Compute LD_LIBRARY_PATH. | ||
| 223 : | # | ||
| 224 : | # Some packages, like mysql, place their shared libs in subdirectories | ||
| 225 : | # of the libdir. | ||
| 226 : | # | ||
| 227 : | |||
| 228 : | my @ld_path = ($env_lib); | ||
| 229 : | |||
| 230 : | my $dh; | ||
| 231 : | if (!opendir($dh, $env_lib)) | ||
| 232 : | { | ||
| 233 : | warn "Could not opendir $env_lib: $!"; | ||
| 234 : | } | ||
| 235 : | |||
| 236 : | while ($_ = readdir($dh)) | ||
| 237 : | { | ||
| 238 : | next if /^\./; | ||
| 239 : | |||
| 240 : | my $path = "$env_lib/$_"; | ||
| 241 : | next unless -d $path; | ||
| 242 : | |||
| 243 : | # | ||
| 244 : | # See if there are any .so's in here. | ||
| 245 : | # | ||
| 246 : | |||
| 247 : | my @solist = <$path/*.so*>; | ||
| 248 : | if (@solist > 0) | ||
| 249 : | { | ||
| 250 : | push(@ld_path, $path); | ||
| 251 : | } | ||
| 252 : | } | ||
| 253 : | closedir($dh); | ||
| 254 : | |||
| 255 : | # | ||
| 256 : | # And if perl is dynamically linked, we need to add the perl core directory | ||
| 257 : | # to the path too. | ||
| 258 : | # | ||
| 259 : | |||
| 260 : | my @coredir = <$env_lib/perl5/*/*/CORE>; | ||
| 261 : | if (@coredir) | ||
| 262 : | { | ||
| 263 : | if ( -f "$coredir[0]/libperl.so" ) | ||
| 264 : | { | ||
| 265 : | print "Found libperl in $coredir[0]\n"; | ||
| 266 : | push(@ld_path, $coredir[0]); | ||
| 267 : | } | ||
| 268 : | } | ||
| 269 : | |||
| 270 : | my $ld_path = join(":", @ld_path); | ||
| 271 : | $OtherConfig->{ld_library_path} = $ld_path; | ||
| 272 : | |||
| 273 : | push(@$Env, ["LD_LIBRARY_PATH", $ld_path, 1]); | ||
| 274 : | olson | 1.11 | |
| 275 : | olson | 1.23 | my @perllib = grep({ $_ ne "." } @INC, |
| 276 : | $release_lib, | ||
| 277 : | "$release_lib/FigKernelPackages", | ||
| 278 : | "$fig_disk/config"); | ||
| 279 : | olson | 1.12 | |
| 280 : | push(@$Env, ["PERL5LIB", join(":", @perllib), 1]); | ||
| 281 : | olson | 1.1 | } |
| 282 : | |||
| 283 : | sub configure_python | ||
| 284 : | { | ||
| 285 : | # | ||
| 286 : | # Determine the PYTHONPATH we're to use. | ||
| 287 : | # | ||
| 288 : | # Right now, we don't compute a replacement for the system path, | ||
| 289 : | # but we're likely going to require that *if* python is | ||
| 290 : | # distributed with the environment. We're currently not doing that. | ||
| 291 : | # | ||
| 292 : | # So we just need to point to any python packages in the release, | ||
| 293 : | # and to packages that were installed in the environment dir. | ||
| 294 : | # | ||
| 295 : | |||
| 296 : | my $python = find_python(); | ||
| 297 : | print "Found python at $python\n"; | ||
| 298 : | |||
| 299 : | my $py_version = `$python -c 'import sys; print "%d.%d" % (sys.version_info[:2])'`; | ||
| 300 : | chomp $py_version; | ||
| 301 : | print "Python version $py_version\n"; | ||
| 302 : | |||
| 303 : | olson | 1.23 | # |
| 304 : | # Python figures this out for us. | ||
| 305 : | #$OtherConfig->{python_site_path} = "$ENV{FIGCONFIG_ENV_DIR}/lib/python$py_version/site-packages"; | ||
| 306 : | olson | 1.2 | |
| 307 : | olson | 1.1 | my @path = (); |
| 308 : | olson | 1.23 | #push(@path, $OtherConfig->{python_site_path}); |
| 309 : | olson | 1.2 | push(@path, "$release_lib"); |
| 310 : | olson | 1.1 | push(@path, "$fig_disk/config"); |
| 311 : | push(@$Env, ["PYTHONPATH", join(":", @path), 1]); | ||
| 312 : | |||
| 313 : | $OtherConfig->{pythonpath} = join(":", @path); | ||
| 314 : | } | ||
| 315 : | |||
| 316 : | sub find_in_path | ||
| 317 : | { | ||
| 318 : | olson | 1.5 | my($file, @extra) = @_; |
| 319 : | olson | 1.1 | my(@path) = split(":", $ENV{PATH}); |
| 320 : | |||
| 321 : | olson | 1.5 | for my $p (@path, @extra) |
| 322 : | olson | 1.1 | { |
| 323 : | my $x = "$p/$file"; | ||
| 324 : | if (-x $x) | ||
| 325 : | { | ||
| 326 : | return $x; | ||
| 327 : | } | ||
| 328 : | } | ||
| 329 : | return undef; | ||
| 330 : | } | ||
| 331 : | |||
| 332 : | # | ||
| 333 : | # Find the name of the python executable we are to use. | ||
| 334 : | # | ||
| 335 : | sub find_python | ||
| 336 : | { | ||
| 337 : | my $python; | ||
| 338 : | |||
| 339 : | # | ||
| 340 : | # Special case for the mac. | ||
| 341 : | # | ||
| 342 : | olson | 1.11 | # RDO 20040603 - don't do this any more; we want to pick up |
| 343 : | # the python we ship. | ||
| 344 : | # | ||
| 345 : | olson | 1.1 | |
| 346 : | olson | 1.11 | if (0 && $ENV{FIGCONFIG_ENV} eq "mac") |
| 347 : | olson | 1.1 | { |
| 348 : | olson | 1.7 | # |
| 349 : | # We'd like to use the MacPython that is installed | ||
| 350 : | # as pythonw. | ||
| 351 : | # | ||
| 352 : | if ($python = find_in_path("pythonw", "/usr/local/bin")) | ||
| 353 : | olson | 1.1 | { |
| 354 : | olson | 1.7 | $OtherConfig->{python_require_poundbang_env} = 1; |
| 355 : | olson | 1.1 | return $python; |
| 356 : | } | ||
| 357 : | |||
| 358 : | # | ||
| 359 : | olson | 1.7 | # Otherwise, we can live with the regular python. |
| 360 : | # Fall thru to the generic case. | ||
| 361 : | olson | 1.1 | # |
| 362 : | olson | 1.7 | } |
| 363 : | # | ||
| 364 : | # Non-mac, just look in the env dir or the path. | ||
| 365 : | # | ||
| 366 : | olson | 1.1 | |
| 367 : | olson | 1.7 | $python = "$ENV{FIGCONFIG_ENV_DIR}/bin/python"; |
| 368 : | if (-x $python) | ||
| 369 : | { | ||
| 370 : | olson | 1.13 | # |
| 371 : | # The mac doesn't seem to like the long #! lines, so we'll use poundbang env. | ||
| 372 : | # | ||
| 373 : | olson | 1.15 | if ($ENV{FIGCONFIG_ENV} =~ /^mac/) |
| 374 : | olson | 1.13 | { |
| 375 : | $OtherConfig->{python_require_poundbang_env} = 1; | ||
| 376 : | } | ||
| 377 : | olson | 1.7 | return $python; |
| 378 : | olson | 1.1 | } |
| 379 : | |||
| 380 : | olson | 1.7 | return find_in_path("python"); |
| 381 : | olson | 1.1 | } |
| 382 : | |||
| 383 : | # | ||
| 384 : | # Find the name of the perl executable we are to use. | ||
| 385 : | # | ||
| 386 : | sub find_perl | ||
| 387 : | { | ||
| 388 : | my $perl; | ||
| 389 : | |||
| 390 : | $perl = "$ENV{FIGCONFIG_ENV_DIR}/bin/perl"; | ||
| 391 : | if (-x $perl) | ||
| 392 : | { | ||
| 393 : | return $perl; | ||
| 394 : | } | ||
| 395 : | |||
| 396 : | warn "We did not find a perl executable in the SEED distribution; some modules may not be found\n"; | ||
| 397 : | return find_in_path("perl"); | ||
| 398 : | } | ||
| 399 : | |||
| 400 : | sub write_bash_init | ||
| 401 : | { | ||
| 402 : | my($fh, $env) = @_; | ||
| 403 : | |||
| 404 : | foreach my $item (@$env) | ||
| 405 : | { | ||
| 406 : | my($name, $value, $append) = @$item; | ||
| 407 : | |||
| 408 : | if ($append) | ||
| 409 : | { | ||
| 410 : | # | ||
| 411 : | # Write code to detect if the value is set, and act accordingly. | ||
| 412 : | # | ||
| 413 : | |||
| 414 : | print $fh <<END; | ||
| 415 : | DELIM= | ||
| 416 : | if [ -n "\$$name" ] ; then | ||
| 417 : | DELIM=: | ||
| 418 : | fi | ||
| 419 : | olson | 1.10 | $name=$value\${DELIM}\${$name} |
| 420 : | olson | 1.1 | export $name |
| 421 : | END | ||
| 422 : | } | ||
| 423 : | else | ||
| 424 : | { | ||
| 425 : | print $fh "$name=\"$value\"\n"; | ||
| 426 : | print $fh "export $name\n"; | ||
| 427 : | } | ||
| 428 : | } | ||
| 429 : | olson | 1.20 | print $fh "alias rtpath='source \$RTDIST/releases/\$RTCURRENT/ReleaseTools/RTPath.sh'\n"; |
| 430 : | olson | 1.1 | } |
| 431 : | |||
| 432 : | sub write_csh_init | ||
| 433 : | { | ||
| 434 : | my($fh, $env) = @_; | ||
| 435 : | |||
| 436 : | foreach my $item (@$env) | ||
| 437 : | { | ||
| 438 : | my($name, $value, $append) = @$item; | ||
| 439 : | |||
| 440 : | if ($append) | ||
| 441 : | { | ||
| 442 : | # | ||
| 443 : | # Write code to detect if the value is set, and act accordingly. | ||
| 444 : | # | ||
| 445 : | |||
| 446 : | print $fh <<END; | ||
| 447 : | if (\$?$name) then | ||
| 448 : | olson | 1.10 | setenv $name $value:\${$name} |
| 449 : | olson | 1.1 | else |
| 450 : | setenv $name $value | ||
| 451 : | endif | ||
| 452 : | END | ||
| 453 : | } | ||
| 454 : | else | ||
| 455 : | { | ||
| 456 : | print $fh "setenv $name \"$value\"\n"; | ||
| 457 : | } | ||
| 458 : | } | ||
| 459 : | |||
| 460 : | olson | 1.20 | # |
| 461 : | # Alias for RT stuff. | ||
| 462 : | # | ||
| 463 : | print $fh "alias rtpath 'source \$RTDIST/releases/\$RTCURRENT/ReleaseTools/RTPath.csh'\n"; | ||
| 464 : | olson | 1.1 | } |
| 465 : | |||
| 466 : | sub run_script | ||
| 467 : | { | ||
| 468 : | my($script) = @_; | ||
| 469 : | |||
| 470 : | |||
| 471 : | unless (my $ret = do $script) | ||
| 472 : | { | ||
| 473 : | if ($@) | ||
| 474 : | { | ||
| 475 : | warn "Error parsing $script: $@\n"; | ||
| 476 : | } | ||
| 477 : | elsif (!defined($ret)) | ||
| 478 : | { | ||
| 479 : | warn "Couldn't do $script: $!\n"; | ||
| 480 : | } | ||
| 481 : | else | ||
| 482 : | { | ||
| 483 : | warn "Counldn't run $script\n"; | ||
| 484 : | } | ||
| 485 : | } | ||
| 486 : | |||
| 487 : | |||
| 488 : | } | ||
| 489 : | |||
| 490 : | sub configure_environment_specific | ||
| 491 : | { | ||
| 492 : | my $env_script = $ENV{FIGCONFIG_ENV_CONFIG}; | ||
| 493 : | |||
| 494 : | if (! -f $env_script) | ||
| 495 : | { | ||
| 496 : | warn "No environment-specific configuration file $env_script found, skipping\n"; | ||
| 497 : | return; | ||
| 498 : | } | ||
| 499 : | |||
| 500 : | run_script($env_script); | ||
| 501 : | } | ||
| 502 : | |||
| 503 : | # | ||
| 504 : | # Create any directories that might be missing. | ||
| 505 : | # | ||
| 506 : | |||
| 507 : | sub setup_directories | ||
| 508 : | { | ||
| 509 : | my(@needed) = @_; | ||
| 510 : | |||
| 511 : | for my $dir (@needed) | ||
| 512 : | { | ||
| 513 : | if (! -d $dir) | ||
| 514 : | { | ||
| 515 : | mkdir($dir) or warn "Could not create $dir: $!\n"; | ||
| 516 : | } | ||
| 517 : | } | ||
| 518 : | } | ||
| 519 : | |||
| 520 : | sub setup_server_scripts | ||
| 521 : | { | ||
| 522 : | # | ||
| 523 : | # Remove any start/stop servers scripts we might have, and write the stub | ||
| 524 : | # start. | ||
| 525 : | # | ||
| 526 : | |||
| 527 : | unlink($start_servers); | ||
| 528 : | unlink($stop_servers); | ||
| 529 : | |||
| 530 : | open(F, ">$start_servers") or die "Cannot write $start_servers: $!"; | ||
| 531 : | print F "#!/bin/sh\n\n"; | ||
| 532 : | close(F); | ||
| 533 : | chmod(0775, $start_servers); | ||
| 534 : | |||
| 535 : | open(F, ">$stop_servers") or die "Cannot write $stop_servers: $!"; | ||
| 536 : | print F "#!/bin/sh\n\n"; | ||
| 537 : | close(F); | ||
| 538 : | chmod(0775, $stop_servers); | ||
| 539 : | |||
| 540 : | } | ||
| 541 : | |||
| 542 : | olson | 1.7 | sub finalize_server_scripts |
| 543 : | { | ||
| 544 : | # | ||
| 545 : | # After any environment-specific stuff, call start_services and stop_services. | ||
| 546 : | # | ||
| 547 : | |||
| 548 : | open(F, ">>$start_servers") or die "Cannot write $start_servers: $!"; | ||
| 549 : | print F "\n$fig_bin/start_services\n"; | ||
| 550 : | close(F); | ||
| 551 : | chmod(0775, $start_servers); | ||
| 552 : | |||
| 553 : | open(F, ">>$stop_servers") or die "Cannot write $stop_servers: $!"; | ||
| 554 : | print F "\n$fig_bin/stop_services\n"; | ||
| 555 : | close(F); | ||
| 556 : | chmod(0775, $stop_servers); | ||
| 557 : | |||
| 558 : | } | ||
| 559 : | |||
| 560 : | olson | 1.1 | sub write_config_pm |
| 561 : | { | ||
| 562 : | my($fh, $config) = @_; | ||
| 563 : | |||
| 564 : | print $fh "package FIG_Config;\n\n"; | ||
| 565 : | |||
| 566 : | foreach my $item (@$config) | ||
| 567 : | { | ||
| 568 : | my($name, $value, $quote) = @$item; | ||
| 569 : | |||
| 570 : | my $q = $quote ? '"' : ''; | ||
| 571 : | printf $fh "\$%-15s = $q$value$q;\n", $name | ||
| 572 : | } | ||
| 573 : | |||
| 574 : | print $fh "\n1;\n"; | ||
| 575 : | } | ||
| 576 : | |||
| 577 : | sub write_config_py | ||
| 578 : | { | ||
| 579 : | my($fh, $config) = @_; | ||
| 580 : | |||
| 581 : | foreach my $item (@$config) | ||
| 582 : | { | ||
| 583 : | my($name, $value, $quote) = @$item; | ||
| 584 : | |||
| 585 : | # | ||
| 586 : | # Ugh. "global" is a keyword in python. | ||
| 587 : | # | ||
| 588 : | |||
| 589 : | $name = "global_dir" if $name eq "global"; | ||
| 590 : | |||
| 591 : | my $q = $quote ? '"' : ''; | ||
| 592 : | printf $fh "%-15s = $q$value$q\n", $name | ||
| 593 : | } | ||
| 594 : | } | ||
| 595 : | |||
| 596 : | sub write_tool_hdr_perl | ||
| 597 : | { | ||
| 598 : | my($fh) = @_; | ||
| 599 : | |||
| 600 : | my $perl = find_perl(); | ||
| 601 : | |||
| 602 : | print $fh "#!$perl\n"; | ||
| 603 : | print $fh "\n"; | ||
| 604 : | |||
| 605 : | if ($::perlenv_override) | ||
| 606 : | { | ||
| 607 : | # | ||
| 608 : | # Write the tool header BEGIN block to reset the environment. | ||
| 609 : | # | ||
| 610 : | |||
| 611 : | print $fh "BEGIN {\n"; | ||
| 612 : | print $fh " \@INC = qw(\n"; | ||
| 613 : | for my $inc (@INC) | ||
| 614 : | { | ||
| 615 : | next if $inc eq '.'; | ||
| 616 : | print $fh "\t$inc\n"; | ||
| 617 : | } | ||
| 618 : | olson | 1.2 | print $fh ");\n"; |
| 619 : | olson | 1.1 | print $fh "}\n"; |
| 620 : | } | ||
| 621 : | |||
| 622 : | print $fh "use Data::Dumper;\n"; | ||
| 623 : | print $fh "use Carp;\n"; | ||
| 624 : | |||
| 625 : | olson | 1.2 | # |
| 626 : | # We generate a comment here that gets expanded by switch_to_release | ||
| 627 : | # This is part of the effort in making the environment bootstrapping | ||
| 628 : | # code independent of releases. | ||
| 629 : | # | ||
| 630 : | |||
| 631 : | #print $fh "use lib \"$release_lib\";\n"; | ||
| 632 : | #print $fh "use lib \"$release_lib/FigKernelPackages\";\n"; | ||
| 633 : | |||
| 634 : | print $fh "# Following block is expanded by switch_to_release to add use lib directives\n"; | ||
| 635 : | print $fh "# to point at the correct locations in the release directory.\n"; | ||
| 636 : | print $fh "#BEGIN switch_to_release generated code\n"; | ||
| 637 : | print $fh "#END switch_to_release generated code\n"; | ||
| 638 : | print $fh "\n"; | ||
| 639 : | |||
| 640 : | olson | 1.1 | print $fh "use lib \"$fig_disk/config\";\n"; |
| 641 : | |||
| 642 : | print $fh "use FIG_Config;\n"; | ||
| 643 : | print $fh "\n"; | ||
| 644 : | olson | 1.11 | print $fh "#### END tool_hdr ####\n\n" |
| 645 : | olson | 1.1 | } |
| 646 : | |||
| 647 : | sub write_tool_hdr_python | ||
| 648 : | { | ||
| 649 : | my($fh) = @_; | ||
| 650 : | |||
| 651 : | my $python = find_python(); | ||
| 652 : | |||
| 653 : | olson | 1.4 | if ($OtherConfig->{python_require_poundbang_env}) |
| 654 : | { | ||
| 655 : | print $fh "#!/usr/bin/env $python\n"; | ||
| 656 : | } | ||
| 657 : | else | ||
| 658 : | { | ||
| 659 : | print $fh "#!$python\n"; | ||
| 660 : | } | ||
| 661 : | olson | 1.1 | print $fh "\n"; |
| 662 : | |||
| 663 : | olson | 1.11 | print $fh "import sys, os\n"; |
| 664 : | olson | 1.2 | |
| 665 : | |||
| 666 : | print $fh "sys.path.append('$OtherConfig->{python_site_path}')\n"; | ||
| 667 : | |||
| 668 : | olson | 1.11 | # |
| 669 : | # Append the perl path to the environment, for use later with CallPerl. | ||
| 670 : | # | ||
| 671 : | |||
| 672 : | olson | 1.23 | my $perlpath = join(":", @INC, $release_lib, "$release_lib/FigKernelPackages", "$fig_disk/config"); |
| 673 : | olson | 1.11 | print $fh <<END; |
| 674 : | if os.getenv("PERL5LIB", "") != "": | ||
| 675 : | _delim = ":" | ||
| 676 : | else: | ||
| 677 : | _delim = "" | ||
| 678 : | os.environ["PERL5LIB"] = "$perlpath" + _delim + os.getenv("PERL5LIB", "") | ||
| 679 : | |||
| 680 : | END | ||
| 681 : | |||
| 682 : | olson | 1.2 | print $fh "# Following block is expanded by switch_to_release to add use lib directives\n"; |
| 683 : | print $fh "# to point at the correct locations in the release directory.\n"; | ||
| 684 : | print $fh "#BEGIN switch_to_release generated code\n"; | ||
| 685 : | print $fh "#END switch_to_release generated code\n"; | ||
| 686 : | print $fh "\n"; | ||
| 687 : | |||
| 688 : | print $fh "sys.path.append('$fig_disk/config')\n"; | ||
| 689 : | |||
| 690 : | olson | 1.1 | print $fh "import FIG_Config\n"; |
| 691 : | print $fh "\n"; | ||
| 692 : | olson | 1.11 | print $fh "#### END tool_hdr_py ####\n\n" |
| 693 : | olson | 1.1 | } |
| 694 : | |||
| 695 : | olson | 1.23 | sub write_rtconfig |
| 696 : | { | ||
| 697 : | my($fh) = @_; | ||
| 698 : | |||
| 699 : | my $python = find_python(); | ||
| 700 : | my $perl = find_perl(); | ||
| 701 : | |||
| 702 : | print $fh "RTPYTHON=$python\n"; | ||
| 703 : | print $fh "RTPERL=$perl\n"; | ||
| 704 : | print $fh "RTPYTHONPATH=$OtherConfig->{pythonpath}\n"; | ||
| 705 : | |||
| 706 : | olson | 1.25 | my %seen; |
| 707 : | my @perlpath; | ||
| 708 : | for (@INC, "$fig_disk/config") | ||
| 709 : | { | ||
| 710 : | next if $seen{$_}; | ||
| 711 : | push(@perlpath, $_); | ||
| 712 : | $seen{$_}++; | ||
| 713 : | } | ||
| 714 : | my $perlpath = join(":", @perlpath); | ||
| 715 : | olson | 1.23 | |
| 716 : | print $fh "RTPERL5LIB=$perlpath\n"; | ||
| 717 : | |||
| 718 : | print $fh "RTPYTHONIMPORTS=FIG_Config\n"; | ||
| 719 : | print $fh "RTPERLIMPORTS=FIG_Config\n"; | ||
| 720 : | olson | 1.25 | print $fh "RTSETENV=BLASTMAT=$fig_disk/BLASTMAT\n"; |
| 721 : | print $fh "RTSETENV=FIG_HOME=$fig_disk\n"; | ||
| 722 : | olson | 1.27 | print $fh "#RTLD_LDPATH=$OtherConfig->{ld_library_path}\n"; |
| 723 : | olson | 1.23 | } |
| 724 : | |||
| 725 : | olson | 1.1 | setup_directories("$fig_disk/bin", |
| 726 : | "$fig_disk/config"); | ||
| 727 : | |||
| 728 : | setup_server_scripts(); | ||
| 729 : | |||
| 730 : | |||
| 731 : | find_python(); | ||
| 732 : | |||
| 733 : | compute_environment(); | ||
| 734 : | configure_std_fig_environment(); | ||
| 735 : | configure_python(); | ||
| 736 : | configure_environment_specific(); | ||
| 737 : | olson | 1.19 | # configure_database(); |
| 738 : | olson | 1.7 | |
| 739 : | finalize_server_scripts(); | ||
| 740 : | olson | 1.1 | |
| 741 : | # | ||
| 742 : | # Write the shell startup to the figdisk. | ||
| 743 : | # | ||
| 744 : | open(FH, ">$fig_disk/config/fig-user-env.sh") or die "Cannot write $fig_disk/config/fig-user-env.sh: $!"; | ||
| 745 : | write_bash_init(\*FH, $Env); | ||
| 746 : | close(FH); | ||
| 747 : | |||
| 748 : | open(FH, ">$fig_disk/config/fig-user-env.csh") or die "Cannot write $fig_disk/config/fig-user-env.csh: $!"; | ||
| 749 : | write_csh_init(\*FH, $Env); | ||
| 750 : | close(FH); | ||
| 751 : | |||
| 752 : | # | ||
| 753 : | # Write the FIG_Config file. | ||
| 754 : | # | ||
| 755 : | |||
| 756 : | open(FH, ">$fig_disk/config/FIG_Config.pm") or die "Cannot write $fig_disk/config/FIG_Config.pm: $!"; | ||
| 757 : | write_config_pm(\*FH, $Config); | ||
| 758 : | close(FH); | ||
| 759 : | |||
| 760 : | open(FH, ">$fig_disk/config/FIG_Config.py") or die "Cannot write $fig_disk/config/FIG_Config.py: $!"; | ||
| 761 : | write_config_py(\*FH, $Config); | ||
| 762 : | close(FH); | ||
| 763 : | |||
| 764 : | # | ||
| 765 : | # Write the tool headers | ||
| 766 : | # | ||
| 767 : | |||
| 768 : | olson | 1.2 | open(FH, ">$fig_disk/config/base_tool_hdr") or die "Cannot write $fig_disk/config/tool_hdr: $!"; |
| 769 : | olson | 1.1 | write_tool_hdr_perl(\*FH); |
| 770 : | close(FH); | ||
| 771 : | |||
| 772 : | olson | 1.2 | open(FH, ">$fig_disk/config/base_tool_hdr_py") or die "Cannot write $fig_disk/config/tool_hdr_py: $!"; |
| 773 : | olson | 1.1 | write_tool_hdr_python(\*FH); |
| 774 : | close(FH); | ||
| 775 : | |||
| 776 : | olson | 1.23 | open(FH, ">$fig_disk/config/RTConfig") or die "Cannot write $fig_disk/config/RTConfig: $!"; |
| 777 : | write_rtconfig(\*FH); | ||
| 778 : | close(FH); | ||
| 779 : | |||
| 780 : | olson | 1.2 | unshift(@INC, "$ENV{FIGCONFIG_RELEASE_DIR}"); |
| 781 : | |||
| 782 : | require FigCommon::SwitchRelease; | ||
| 783 : | olson | 1.1 | |
| 784 : | olson | 1.16 | # |
| 785 : | # We need to tweak the current path and PERL5LIB environment to get bootstrapping to | ||
| 786 : | # work correctly. | ||
| 787 : | # | ||
| 788 : | |||
| 789 : | $ENV{PATH} = "$ENV{FIGCONFIG_ENVDIR}/bin:$ENV{PATH}"; | ||
| 790 : | |||
| 791 : | olson | 1.17 | $ENV{PERL5LIB} = (map { $_->[1] } grep { $_->[0] eq "PERL5LIB"} @$Env)[0]; |
| 792 : | olson | 1.16 | |
| 793 : | olson | 1.2 | &FigCommon::SwitchRelease::switch_to_release($fig_disk, $ENV{FIGCONFIG_ENV}, $ENV{FIGCONFIG_RELEASE}); |
| MCS Webmaster | ViewVC Help |
| Powered by ViewVC 1.0.3 |