[tex-live] pretest: install hangs (was re: path not set)
Norbert Preining
preining at logic.at
Wed Jul 8 11:16:02 CEST 2009
On Mi, 08 Jul 2009, Norbert Preining wrote:
> - replace the files you are using for installation with the attached
> files:
Now they are attached
> - install-tl should go into the tlnet/ folder
> - TLUtils.pm and TLWinGoo.pm should go into tlnet/tlpkg/TeXLive folder
>
> - then restart the installation with
> install-tl -v -gui
> and *PLEASE* select the scheme-minimal, that makes everything faster
> for you, no need to make a scheme-full installation.
>
> After that please send me as before install-tl.log, and also the
> texlive.profile that is created alongside the .log file (or in the tlpkg
> folder)
Best wishes
Norbert
-------------------------------------------------------------------------------
Dr. Norbert Preining <preining at logic.at> Vienna University of Technology
Debian Developer <preining at debian.org> Debian TeX Group
gpg DSA: 0x09C5B094 fp: 14DF 2E6C 0307 BE6D AD76 A9C0 D2BF 4AA3 09C5 B094
-------------------------------------------------------------------------------
NEEN SOLLARS (pl.n.)
Any ensemble of especially unflattering and particular garments worn
by a woman which tell you that she is right at the forefront of
fashion.
--- Douglas Adams, The Meaning of Liff
-------------- next part --------------
#!/usr/bin/env perl
# $Id: install-tl 14177 2009-07-07 21:53:26Z karl $
#
# Copyright 2007, 2008, 2009 Reinhard Kotucha, Norbert Preining
# This file is licensed under the GNU General Public License version 2
# or any later version.
#
# Be careful when changing wording: Every normal informational message
# output here must be recognized by the long grep in tl-update-tlnet.
#
# TODO:
# - with -gui pop up a transient window showing:
# testing for compressed archive packages ...
# testing for uncompressed live system ...
# testing for network access ...
# loading tlpdb, this can take some time ...
# (that, and maybe some others can be done with the waitVariableX
# thingy as described in the Perl/Tk book in the chapter that can be
# found on the net) (Werner 28.10.08)
# - at the end of the installation after the welcome message if there
# was an error during installation (grep for Error in the logfile)
# then give a warning. (email hh tlbuild 2009-06-03)
my $svnrev = '$Revision: 14177 $';
$svnrev =~ m/: ([0-9]+) /;
$::installerrevision = $1;
# taken from 00texlive.config: release, $tlpdb->config_release;
our $texlive_release;
BEGIN {
$^W = 1;
my $Master;
my $me = $0;
$me =~ s!\\!/!g if $^O =~ /^MSWin(32|64)$/i;
if ($me =~ m!/!) {
($Master = $me) =~ s!(.*)/[^/]*$!$1!;
} else {
$Master = ".";
}
$::installerdir = $Master;
# All platforms: add the installer modules
unshift (@INC, "$::installerdir/tlpkg");
}
use Cwd 'abs_path';
use Getopt::Long qw(:config no_autoabbrev);
use Pod::Usage;
use TeXLive::TLUtils qw(platform platform_desc
which getenv win32 unix info log debug tlwarn ddebug
get_system_tmpdir member process_logging_options rmtree
mkdirhier make_var_skeleton make_local_skeleton install_package copy
install_packages dirname setup_programs welcome welcome_paths);
#use TeXLive::TLMedia;
use TeXLive::TLPOBJ;
use TeXLive::TLPDB;
use TeXLive::TLConfig;
if (win32) {
require TeXLive::TLWinGoo;
TeXLive::TLWinGoo->import( qw(
&win_version
&is_vista
&admin
&non_admin
®_country
&expand_string
&global_tmpdir
&get_system_path
&get_user_path
&setenv_reg
&unsetenv_reg
&adjust_reg_path_for_texlive
®ister_extension
&unregister_extension
®ister_file_type
&unregister_file_type
&broadcast_env
&update_assocs
&add_desktop_shortcut
&add_menu_shortcut
&remove_desktop_shortcut
&remove_menu_shortcut
&create_uninstaller
));
}
use strict;
# debugging/logging cmd lines options:
# -q shut up terminal output but warning messages
# -v do a bit of debugging to stdout and logfile
# repeated use increases the value of verbosity
#
@::LOGLINES = ();
#
# $install{$packagename} == 1 if it should be installed
my %install;
#
# the different modules have to assign a code blob to this global variable
# which starts the installation.
# Example: In install-menu-text.pl there is
# $::run_menu = \&run_menu_text;
#
$::run_menu = sub { die "no UI defined." ; };
# the default scheme to be installed
my $default_scheme='scheme-full';
# some arrays where the lists of collections to be installed are saved
# our for menus
our @collections_std;
our @collections_lang;
our @collections_lang_doc;
# The global variable %vars is an associative list which contains all
# variables and their values which can be changed by the user.
# needs to be our since TeXLive::TLUtils uses it
#
# The following values are taken from the remote tlpdb using the
# $tlpdb->option_XXXXX
# settings (i.e., taken from tlpkg/tlpsrc/00texlive.installation.tlpsrc
#
# 'option_path' => 0,
# 'option_sys_bin' => '/usr/local/bin',
# 'option_sys_man' => '/usr/local/man',
# 'option_sys_info' => '/usr/local/info',
# 'option_doc' => 1,
# 'option_src' => 1,
# 'option_fmt' => 0,
# 'option_letter' => 0,
our %vars=( # 'n_' means 'number of'.
'this_platform' => '',
'n_systems_available' => 0,
'n_systems_selected' => 0,
'n_collections_selected' => 0,
'n_collections_available' => 0,
'total_size' => 0,
'src_splitting_supported' => 1,
'doc_splitting_supported' => 1,
'selected_scheme' => $default_scheme,
'from_dvd' => 0,
);
# option handling
my $opt_from_dvd = "";
my $opt_gui = (win32() ? "wizard" : "text");
my $opt_help = 0;
my $opt_location = "";
my $opt_no_gui = 0;
my $opt_nonadmin = 0;
my $opt_portable = 0;
my $opt_print_arch = 0;
my $opt_profileseed = "";
my $opt_profile = "";
my $opt_scheme = "";
my $opt_custom_bin;
my $opt_version = 0;
my $opt_force_arch;
# default language for GUI installer
$::lang = "en";
# use the fancy directory selector for TEXDIR
$::alternative_selector = 0;
# if we find a file installation.profile we ask the user whether we should
# continue with the installation
# note, we are in the installer directory.
if (-r "installation.profile") {
print "ABORTED INSTALLATION FOUND: installation.profile\n";
print "Do you want to continue with the exact same settings as before (y/N): ";
my $answer = <STDIN>;
if ($answer =~ m/^y(es)?$/i) {
$opt_profile = "installation.profile";
}
}
# first process verbosity/quiet options
process_logging_options();
# now the others
GetOptions(
"custom-bin=s" => \$opt_custom_bin,
"fancyselector" => \$::alternative_selector,
"from_dvd" => \$opt_from_dvd,
"gui:s" => \$opt_gui,
"lang=s" => \$::opt_lang,
"location|url=s" => \$opt_location,
"no-cls", # $::opt_no_cls in install-menu-text-pl
"no-gui" => \$opt_no_gui,
"non-admin" => \$opt_nonadmin,
"portable" => \$opt_portable,
"print-arch" => \$opt_print_arch,
"force-arch=s" => \$opt_force_arch,
"profile-seed=s" => \$opt_profileseed,
"profile=s" => \$opt_profile,
"scheme=s" => \$opt_scheme,
"version" => \$opt_version,
"help|?" => \$opt_help) or pod2usage(1);
if ($opt_gui eq "") {
# the --gui option was given with an empty argument, set it to perltk
$opt_gui = "perltk";
}
if ($opt_gui eq "expert") {
$opt_gui = "perltk";
}
if (win32()) {
pod2usage(-exitstatus => 0,
-verbose => 2,
-noperldoc => 1,
-output => \*STDOUT) if $opt_help;
} else {
pod2usage(-exitstatus => 0, -verbose => 2, -file => $0) if $opt_help;
}
if ($opt_version) {
print "install-tl (TeX Live Cross Platform Installer)",
" revision $::installerrevision\n";
if (open (REL_TL, "$::installerdir/release-texlive.txt")) {
# print first and last lines, which have the TL version info.
my @rel_tl = <REL_TL>;
print $rel_tl[0];
print $rel_tl[$#rel_tl];
close (REL_TL);
}
exit 0;
}
if ($#ARGV >= 0) {
# we still have arguments left, should only be gui, otherwise die
if ($ARGV[0] =~ m/^gui$/i) {
$opt_gui = "perltk";
} else {
die "$0: Extra arguments `@ARGV'; try --help if you need it.\n";
}
}
if (defined($::opt_lang)) {
$::lang = $::opt_lang;
}
if ($opt_profile) {
if (-r $opt_profile) {
info("Automated TeX Live installation using profile: $opt_profile\n");
} else {
$opt_profile = "";
info("Profile $opt_profile not readable, continuing in interactive mode.\n");
}
}
if ($opt_nonadmin and win32()) {
non_admin();
}
# the TLPDB instances we will use. $tlpdb is for the one from the installation
# media, while $localtlpdb is for the new installation
# $tlpdb must be our because it is used in install-menu-text.pl
our $tlpdb;
our $previoustlpdb;
my $localtlpdb;
my $location;
# $finished == 1 if the menu call already did the installation
my $finished = 0;
@::info_hook = ();
my $system_tmpdir=get_system_tmpdir();
my $media;
# special uses of install-tl:
if ($opt_print_arch) {
print platform()."\n";
exit 0;
} elsif ($opt_portable) {
&do_portable ();
}
# continuing with normal install
# check as soon as possible for GUI functionality to give people a chance
# tp interrupt.
if (($opt_gui ne "text") && !$opt_no_gui && ($opt_profile eq "")) {
# try to load Tk.pm, but don't die if it doesn't work
eval { require Tk; };
if ($@) {
# that didn't work out, so warn the user and continue with text mode
tlwarn("Cannot load Tk, maybe something is missing and\n");
tlwarn("maybe http://tug.org/texlive/distro.html#perltk can help.\n");
tlwarn("Error message from loading Tk:\n");
tlwarn(" $@\n");
tlwarn("Continuing in text mode...\n");
$opt_gui = "text";
}
eval { my $foo = Tk::MainWindow->new; $foo->destroy; };
if ($@) {
tlwarn("perl/Tk unusable, cannot create main windows.\n");
if (platform() eq "universal-darwin") {
tlwarn("That could be because X11 is not installed or started.\n");
}
tlwarn("Error message from creating MainWindow:\n");
tlwarn(" $@\n");
tlwarn("Continuing in text mode...\n");
$opt_gui = "text";
}
if ($opt_gui eq "text") {
# we switched from GUI to non-GUI mode, tell the user and wait a bit
tlwarn("\nSwitching to text mode installer, if you want to cancel, do it now.\n");
tlwarn("Waiting for 3 second\n");
sleep(3);
}
}
# initialize the correct platform
platform();
# we do not support cygwin < 1.7, so check for that
if (!$opt_custom_bin && (platform() eq "i386-cygwin")) {
chomp( my $un = `uname -r`);
if ($un =~ m/^(\d+)\.(\d+)\./) {
if ($1 < 2 && $2 < 7) {
tldie("\nSorry, the TL binaries require at least cygwin 1.7.\n");
}
}
}
if (!setup_programs ("$::installerdir/tlpkg/installer", "$::_platform_")) {
tldie("$0: Goodbye.\n");
}
# determine where we will find the distribution to install from.
#
$location = $opt_location;
$location || ($location = "$::installerdir");
if ($location =~ m!^(ctan$|(http|ftp)://)!i) {
$location =~ s,/(tlpkg|archive)?/*$,,; # remove any trailing tlpkg or /
if ($location =~ m/^($TeXLiveServerURL|ctan$)/) {
$location = TeXLive::TLUtils::give_ctan_mirror();
}
$TeXLiveURL = $location;
$media = 'NET';
} else {
# remove leading file:/+ part
$location =~ s!^file://*!/!i;
$location = abs_path($location);
if (-d "$location/$Archive") {
$media='CD';
} elsif (-d "$location/texmf/web2c") {
$media='DVD';
} else {
if ($opt_location) {
# user gave a --location but nothing can be found there, so die
die "$0: cannot find installation source at $opt_location.\n";
}
# no --location given, but NET installation
$TeXLiveURL = $location = TeXLive::TLUtils::give_ctan_mirror();
$media = 'NET';
}
}
info("Installing TeX Live $TeXLive::TLConfig::ReleaseYear from: $location\n");
if (defined($opt_force_arch)) {
tlwarn("Overriding platform to $opt_force_arch\n");
$::_platform_ = $opt_force_arch;
}
$vars{'this_platform'} = $::_platform_;
info("Platform: ", platform, " => \'", platform_desc(platform), "\'\n");
if ($opt_custom_bin) {
if (-d $opt_custom_bin) {
info("Platform overridden, binaries taken from $opt_custom_bin\nand put into bin/custom!\n");
} else {
tldie("Argument for -custom-bin needs to be directory with TeX Live binaries!\n");
}
}
if ($media eq "DVD") {
info("Distribution: live (uncompressed)\n");
} elsif ($media eq "CD") {
info("Distribution: inst (compressed)\n");
} elsif ($media eq "NET") {
info("Distribution: net (downloading)\n");
info("Using URL: $TeXLiveURL\n");
} else {
info("Distribution: $media\n");
}
info("Directory for temporary files: $system_tmpdir\n");
if ($opt_from_dvd and ($media ne "DVD")) {
print "Not running from DVD; 'from_dvd' option not applicable\n";
$opt_from_dvd = 0;
}
$vars{'from_dvd'} = $opt_from_dvd;
load_tlpdb();
log("Installer revision: $::installerrevision\n");
log("Database revision: " . $tlpdb->config_revision . "\n");
# correctly set the splitting support
# for DVD we always support splitting
if (($media eq "NET") || ($media eq "CD")) {
$vars{'src_splitting_supported'} = $tlpdb->config_src_container;
$vars{'doc_splitting_supported'} = $tlpdb->config_doc_container;
}
$texlive_release = $tlpdb->config_release;
# if the release from the remote TLPDB does not agree with the
# TLConfig::ReleaseYear in the first 4 places break out here.
# Why only the first four places: some optional network distributions
# might use
# release/2009-foobar
if ($texlive_release !~ m/^$TeXLive::TLConfig::ReleaseYear/) {
die "The release version of the installation source and\nthe installation media do not agree:\nsource: $texlive_release\nmedia: $TeXLive::TLConfig::ReleaseYear\nPlease report to tex-live\@tug.org";
}
set_platforms_supported();
set_texlive_default_dirs();
initialize_collections();
set_install_platform();
# initialize the scheme from the command line value, if given.
if ($opt_scheme) {
# add the scheme- prefix if they didn't give it.
$opt_scheme = "scheme-$opt_scheme" if $opt_scheme !~ /^scheme-/;
my $scheme = $tlpdb->get_package($opt_scheme);
if (defined($scheme)) {
select_scheme($opt_scheme); # select it
} else {
tlwarn("Scheme $opt_scheme not defined, ignoring it.\n");
}
}
if ($opt_profile eq "") {
if ($opt_profileseed) {
read_profile("$opt_profileseed");
}
# do the normal interactive installation.
#
# here we could load different menu systems. Currently several things
# are "our" so that the menu implementation can use it. The $tlpdb, the
# %var, and all the @collection*
# install-menu-*.pl have to assign a code ref to $::run_menu which is
# run, and should change ONLY stuff in %vars
# The allowed keys in %vars should be specified somewhere ...
# the menu implementation should return
# MENU_INSTALL do the installation
# MENU_ABORT abort every action immediately, no cleanup
# MENU_QUIT try to quit and clean up mess
our $MENU_INSTALL = 0;
our $MENU_ABORT = 1;
our $MENU_QUIT = 2;
our $MENU_ALREADYDONE = 3;
$opt_gui = "text" if ($opt_no_gui);
# finally do check for additional screens in the $opt_gui setting:
# format:
# --gui <plugin>:<a1>,<a2>,...
# which will passed to run_menu (<a1>, <a2>, ...)
#
my @runargs;
if ($opt_gui =~ m/^([^:]*):(.*)$/) {
$opt_gui = $1;
@runargs = split ",", $2;
}
if (-r "$::installerdir/tlpkg/installer/install-menu-${opt_gui}.pl") {
require("installer/install-menu-${opt_gui}.pl");
} else {
tlwarn("UI plugin $opt_gui not found,\n");
tlwarn("Using text mode installer.\n");
require("installer/install-menu-text.pl");
}
# before we start the installation we check for the existence of
# a previous installation, and in case we ship inform the UI
{
my $tlmgrwhich = which("tlmgr");
if ($tlmgrwhich) {
my $dn = dirname($tlmgrwhich);
$dn = abs_path("$dn/../..");
my $tlpdboldpath = "$dn/$TeXLive::TLConfig::InfraLocation/$TeXLive::TLConfig::DatabaseName";
if (-r $tlpdboldpath) {
# we found an old installation, so read that one in and save
# the list installed collections into an array.
$previoustlpdb = TeXLive::TLPDB->new(root => $dn);
if ($previoustlpdb) {
debug ("found old installation in $dn\n");
push @runargs, "-old-installation-found";
}
}
}
}
my $ret = &{$::run_menu}(@runargs);
if ($ret == $MENU_QUIT) {
do_cleanup();
flushlog();
exit(1);
}
if ($ret == $MENU_ABORT) {
# omit do_cleanup().
flushlog();
exit(2);
}
if ($ret == $MENU_ALREADYDONE) {
debug("run_menu has already done the work ... cleaning up.\n");
$finished = 1;
}
if (!$finished && ($ret != $MENU_INSTALL)) {
tlwarn("Unknown return value of run_menu: $ret\n");
exit(3);
}
} else {
read_profile($opt_profile);
}
if (!$finished) {
# do the actual installation
# win32: first, remove trailing slash from texdir[w]
# in case it is the root of a drive
$vars{'TEXDIR'} =~ s![/\\]$!!;
$vars{'TEXDIRW'} =~ s![/\\]$!!;
info("Installing to: $vars{TEXDIRW}\n");
do_installation();
}
do_cleanup();
exit(0);
###################################################################
#
# FROM HERE ON ONLY SUBROUTINES
# NO VARIABLE DECLARATIONS
#
###################################################################
sub do_installation {
if (win32()) {
debug("Switching to non-admin mode due to explicit user request!\n");
non_admin() if !$vars{'option_w32_multi_user'};
}
# do the actual installation
my $h;
prepare_installation();
if (!$vars{'from_dvd'}) {
calc_depends();
save_options_into_tlpdb();
do_install_packages();
if ($opt_custom_bin) {
$vars{'this_platform'} = "custom";
my $TEXDIR="$vars{'TEXDIR'}";
mkdirhier("$TEXDIR/bin/custom");
for my $f (<$opt_custom_bin/*>) {
copy($f, "$TEXDIR/bin/custom");
}
}
}
# now we save every scheme that is fully covered by the stuff we have
# installed to the $localtlpdb
foreach my $s ($tlpdb->schemes) {
my $stlp = $tlpdb->get_package($s);
die ("That cannot happen, $s not defined in tlpdb") unless defined($stlp);
my $incit = 1;
foreach my $d ($stlp->depends) {
if (!defined($localtlpdb->get_package($d))) {
$incit = 0;
last;
}
}
if ($incit) {
$localtlpdb->add_tlpobj($stlp);
}
}
$localtlpdb->save unless $vars{'from_dvd'};
do_postinst_stuff();
if (win32()) {
print welcome();
} else {
print welcome_paths();
}
}
# do_postinst_stuff has to fix up the texmf tree and install some missing
# files. The things to do are taken from the install-live.sh installer
# of former times, and should be critically checked.
sub do_postinst_stuff {
my $TEXDIR="$vars{'TEXDIR'}";
my $TEXDIRW="$vars{'TEXDIRW'}";
my $TEXMFSYSVAR="$vars{'TEXMFSYSVAR'}";
my $TEXMFSYSCONFIG="$vars{'TEXMFSYSCONFIG'}";
my $TEXMFLOCAL="$vars{'TEXMFLOCAL'}";
my $tmv;
do_texmf_cnf() unless ($opt_portable);
#
# clean up useless files in texmf-dist/tlpkg as this is only
# created by the relocatable packages
if (-d "$TEXDIR/$TeXLive::TLConfig::RelocTree/tlpkg") {
rmtree("$TEXDIR/TeXLive::TLConfig::RelocTree/tlpkg");
}
# final program execution
# we have to do several things:
# - clean the environment from spurious TEXMF related variables
# - add the bin dir to the PATH
# - select perl interpreter and set the correct perllib
# - run the programs
# Step 1: Clean the environment
my @TMFVARS0=qw(VARTEXFONTS
TEXMF SYSTEXMF VARTEXFONTS
TEXMFDBS WEB2C TEXINPUTS TEXFORMATS MFBASES MPMEMS TEXPOOL MFPOOL MPPOOL
PSHEADERS TEXFONTMAPS TEXPSHEADERS TEXCONFIG TEXMFCNF);
my @TMFVARS1=qw(TEXMFMAIN TEXMFDIST TEXMFLOCAL TEXMFSYSVAR TEXMFSYSCONFIG
TEXMFHOME TEXMFVAR TEXMFCONFIG);
if (defined($ENV{'TEXMFCNF'}) and !$vars{'from_dvd'} and !$opt_portable) {
print "WARNING: environment variable TEXMFCNF is set.
You should know what you are doing.
We will remove that for the post install actions, but all further
operations might be disturbed.\n\n";
}
foreach $tmv (@TMFVARS0) {
delete $ENV{$tmv} if (defined($ENV{$tmv}));
}
if (!$opt_portable) {
foreach $tmv (@TMFVARS1) {
delete $ENV{$tmv} if (defined($ENV{$tmv}));
}
}
if ($vars{'from_dvd'}) {
$ENV{'TEXMFSYSVAR'} = $vars{'TEXMFSYSVAR'};
$ENV{'TEXMFCNF'} = $vars{'TEXMFSYSVAR'}."/web2c";
}
# Step 2: Setup the PATH, switch to the new Perl
my $pathsep=(win32)? ';' : ':';
my $plat_bindir="$TEXDIR/bin/$vars{'this_platform'}";
my $perl_bindir="$TEXDIR/tlpkg/tlperl/bin";
my $perl_libdir="$TEXDIR/tlpkg/tlperl/lib";
## This won't do any good;
## have to remove other tex directories in calling batchfile
# if (win32) {
# debug("Removing other TeXs from path\n");
# my @newpt = ();
# foreach my $d (split (';', $ENV{'PATH'})) {
# push @newpt, $d unless TeXLive::TLWinGoo::is_a_texdir($d);
# }
# $ENV{'PATH'} = join($pathsep, @newpt);
# debug("Path after removals(s):\n $ENV{'PATH'}\n");
# }
debug("Prepending $plat_bindir to PATH\n");
$ENV{'PATH'}="$plat_bindir" . "$pathsep" . "$ENV{'PATH'}";
if (win32) {
debug("Prepending $perl_bindir to PATH\n");
$ENV{'PATH'}="$perl_bindir" . "$pathsep" . "$ENV{'PATH'}";
$ENV{'PATH'} =~ s!/!\\!g;
}
debug("\nNew PATH is now:\n");
foreach my $dir (split $pathsep, $ENV{'PATH'}) {
debug(" $dir\n");
}
debug("\n");
if (win32) {
$ENV{'PERL5LIB'}="$perl_libdir";
}
#
# post install actions
#
# in case we are running from DVD we use the tlpdb from the DVD, otherwise
# the one we have locally created, for all the further actions
my $usedtlpdb = $vars{'from_dvd'} ? $tlpdb : $localtlpdb;
if (win32()) {
debug "Actual environment:\n".`set`."\n\n";
debug 'Effective TEXMFCNF: '.`kpsewhich -expand-path=\$TEXMFCNF`."\n";
}
# TODO: can the following two clauses be merged?
if (win32()) {
create_uninstaller($vars{'TEXDIR'}, $vars{'TEXDIRW'},
$vars{'TEXMFSYSVAR'}, $vars{'TEXMFSYSCONFIG'});
}
# (re-)initialize batchfile for uninstalling shortcuts
if (win32() and !$opt_portable) {
mkdirhier("$TEXDIRW/tlpkg/installer") if $vars{'from_dvd'};
}
# Step 4: run the programs
if (!$opt_portable and !$vars{'from_dvd'}) {
info("running mktexlsr $TEXDIR/texmf-dist $TEXDIR/texmf\n");
system('mktexlsr', "$TEXDIR/texmf-dist", "$TEXDIR/texmf");
}
# we have to generate the various config file. That could be done with
# texconfig generate * but Win32 does not have texconfig. But we have
# $localtlpdb and this is simple code, so do it directly, i.e., duplicate
# the code from the various generate-*.pl scripts
info("writing fmtutil.cnf data to $TEXMFSYSVAR/web2c/fmtutil.cnf\n");
TeXLive::TLUtils::create_fmtutil($usedtlpdb,
"$TEXMFSYSVAR/web2c/fmtutil.cnf",
"$TEXMFLOCAL/web2c/fmtutil-local.cnf");
mkdirhier "$vars{'TEXMFSYSCONFIG'}/web2c";
info("writing updmap.cfg to $TEXMFSYSCONFIG/web2c/updmap.cfg\n");
TeXLive::TLUtils::create_updmap ($usedtlpdb,
"$TEXMFSYSCONFIG/web2c/updmap.cfg",
"$TEXMFLOCAL/web2c/updmap-local.cfg");
info("writing language.dat data to $TEXMFSYSVAR/tex/generic/config/language.dat\n");
TeXLive::TLUtils::create_language_dat($usedtlpdb,
"$TEXMFSYSVAR/tex/generic/config/language.dat",
"$TEXMFLOCAL/tex/generic/config/language-local.dat");
info("writing language.def data to $TEXMFSYSVAR/tex/generic/config/language.def\n");
TeXLive::TLUtils::create_language_def($usedtlpdb,
"$TEXMFSYSVAR/tex/generic/config/language.def",
"$TEXMFLOCAL/tex/generic/config/language-local.def");
info("running mktexlsr $TEXMFSYSVAR\n");
system('mktexlsr', "$TEXMFSYSVAR");
info("running updmap-sys... ");
# system('updmap-sys', '--nohash');
log(`updmap-sys --nohash 2>&1`);
info("done\n");
info("re-running mktexlsr $TEXMFSYSVAR\n");
system('mktexlsr', "$TEXMFSYSVAR");
# now work through the options if specified at all
# letter instead of a4
if ($vars{'option_letter'}) {
info("Setting default paper size to letter\n");
system("tlmgr", "paper", "letter");
}
# all formats option
if ($vars{'option_fmt'}) {
info("pre-generating all format files (fmtutil-sys --all), be patient...");
log(`fmtutil-sys --all 2>&1`);
info("done\n");
}
#
# do path adjustments: On Windows add/remove to PATH etc, on Unix
# set symlinks
do_path_adjustments() if $vars{'option_path'};
# no do the system integration:
# on unix this means setting up symlinks
# on w32 this means adding to path, settting registry values
# on both, we run the postaction directives of the tlp
do_tlpdb_postactions();
}
sub do_tlpdb_postactions {
info ("running package specific postactions\n");
# Run the post installation code in the postaction tlpsrc entries
my $usedtlpdb = $vars{'from_dvd'} ? $tlpdb : $localtlpdb;
foreach my $package (sort keys %install) {
if ($install{$package}) {
&TeXLive::TLUtils::do_postaction("install",
$usedtlpdb->get_package($package),
$vars{'option_file_assocs'},
$vars{'option_desktop_integration'},
$vars{'option_post_code'});
}
}
info ("finished with package specific postactions\n");
}
sub do_path_adjustments {
info ("running path adjustment actions\n");
if (win32()) {
TeXLive::TLUtils::w32_add_to_path($vars{'TEXDIR'}.'/bin/win32',
$vars{'option_w32_multi_user'});
#
# from_dvd stuff
# setenv_reg('TEXMFSYSVAR', $vars{'TEXMFSYSVAR'}) if $vars{'from_dvd'};
setenv_reg('TEXMFCNF', $vars{'TEXMFSYSVAR'}.'/web2c') if $vars{'from_dvd'};
broadcast_env();
} else {
TeXLive::TLUtils::add_symlinks($vars{'TEXDIR'}, $vars{'this_platform'},
$vars{'option_sys_bin'}, $vars{'option_sys_man'},
$vars{'option_sys_info'});
}
info ("finished with path adjustment actions\n");
}
# we have to adjust the texmf.cnf file to the paths set in the configuration!
sub do_texmf_cnf {
open(TMF,"<$vars{'TEXDIR'}/texmf/web2c/texmf.cnf")
or die "$vars{'TEXDIR'}/texmf/web2c/texmf.cnf not found: $!";
my @texmfcnflines = <TMF>;
close(TMF);
my @newtmf;
my @changedtmf;
# we have to find TEXMFLOCAL TEXMFSYSVAR and TEXMFHOME
foreach my $line (@texmfcnflines) {
if ($line =~ m/^TEXMFLOCAL/) {
# by default TEXMFLOCAL = TEXDIR/../texmf-local, if this is the case
# we don't have to change anything from the default
my $deftmlocal = dirname($vars{'TEXDIR'});
$deftmlocal .= "/texmf-local";
if ("$vars{'TEXMFLOCAL'}" eq "$deftmlocal") {
push @newtmf, $line;
} else {
push @newtmf, "TEXMFLOCAL = $vars{'TEXMFLOCAL'}\n";
push @changedtmf, "TEXMFLOCAL = $vars{'TEXMFLOCAL'}\n";
}
} elsif ($line =~ m/^TEXMFSYSVAR/) {
# by default TEXMFSYSVAR = TEXDIR/texmf-var, if this is the case
# we don't have to change anything from the default
if ("$vars{'TEXMFSYSVAR'}" eq "$vars{'TEXDIR'}/texmf-var") {
push @newtmf, $line;
} else {
push @newtmf, "TEXMFSYSVAR = $vars{'TEXMFSYSVAR'}\n";
push @changedtmf, "TEXMFSYSVAR = $vars{'TEXMFSYSVAR'}\n";
}
} elsif ($line =~ m/^TEXMFSYSCONFIG/) {
# by default TEXMFSYSCONFIG = TEXDIR/texmf-config, if this is the case
# we don't have to change anything from the default
if ("$vars{'TEXMFSYSCONFIG'}" eq "$vars{'TEXDIR'}/texmf-config") {
push @newtmf, $line;
} else {
push @newtmf, "TEXMFSYSCONFIG = $vars{'TEXMFSYSCONFIG'}\n";
push @changedtmf, "TEXMFSYSCONFIG = $vars{'TEXMFSYSCONFIG'}\n";
}
} elsif ($line =~ m/^TEXMFHOME/) {
# kpse now expands ~ to USERPROFILE, so we don't treat win32 and
# unix differently
push @newtmf, "TEXMFHOME = $vars{'TEXMFHOME'}\n";
if ("$vars{'TEXMFHOME'}" ne "~/texmf") {
push @changedtmf, "TEXMFHOME = $vars{'TEXMFHOME'}\n";
}
} elsif ($line =~ m/^OSFONTDIR/) {
if (win32()) {
push @newtmf, "OSFONTDIR = \$SystemRoot/fonts//\n";
push @changedtmf, "OSFONTDIR = \$SystemRoot/fonts//\n";
} else {
push @newtmf, $line;
}
} else {
push @newtmf, $line;
}
}
my $TMF;
if (!$vars{'from_dvd'}) {
$TMF = ">$vars{'TEXDIR'}/texmf.cnf";
open(TMF, $TMF) || die "open($TMF) failed: $!";
print TMF <<EOF;
% This texmf.cnf file should contain only your personal changes from the
% main texmf.cnf.
%
% Do NOT change values in the main file (which is in
% .../texlive/YYYY/texmf/web2c/texmf.cnf), as YOUR CHANGES WILL BE LOST
% by later updates.
%
% If you need to make changes to texmf.cnf, put your custom settings in
% this file instead, which is YYYY/texmf.cnf. And insert *only* your
% changed values.
%
EOF
;
foreach (@changedtmf) { print TMF; }
} else {
$TMF = ">$vars{'TEXMFSYSVAR'}/web2c/texmf.cnf";
open (TMF, $TMF) || die "open($TMF) failed: $!\n";
foreach (@newtmf) { print TMF; }
}
close(TMF) || warn "close($TMF) failed: $!";
}
sub dump_vars {
my $filename=shift;
my $fh;
if (ref($filename)) {
$fh = $filename;
} else {
open VARS, ">$filename";
$fh = \*VARS;
}
foreach my $key (keys %vars) {
print $fh "$key $vars{$key}\n";
}
close VARS if (!ref($filename));
debug("\n%vars dumped to '$filename'.\n");
}
# Determine which platforms are supported.
sub set_platforms_supported {
my @binaries = $tlpdb->available_architectures;
for my $binary (@binaries) {
unless (defined $vars{"binary_$binary"}) {
$vars{"binary_$binary"}=0;
}
}
for my $key (keys %vars) {
++$vars{'n_systems_available'} if ($key=~/^binary/);
}
}
# Environment variables and default values on UNIX:
# TEXLIVE_INSTALL_PREFIX /usr/local/texlive => $tex_prefix
# TEXLIVE_INSTALL_TEXDIR $tex_prefix/2007 => $TEXDIR
# TEXLIVE_INSTALL_TEXMFSYSVAR $TEXDIR/texmf-var
# TEXLIVE_INSTALL_TEXMFSYSCONFIG $TEXDIR/texmf-config
# TEXLIVE_INSTALL_TEXMFLOCAL $tex_prefix/texmf-local
# TEXLIVE_INSTALL_TEXMFHOME '$HOME/texmf'
sub set_texlive_default_dirs {
my $tex_prefix;
my $texmfsysvar;
my $texmfsysconfig;
my $texmflocal;
my $texmfhome;
$tex_prefix=getenv('TEXLIVE_INSTALL_PREFIX');
if (win32) {
my $prog = getenv('ProgramFiles');
$tex_prefix ||= $prog . '/texlive';
# $tex_prefix ||= $prog . '/texlive' if TeXLive::TLWinGoo::dir_writable($prog);
# $tex_prefix||=getenv('USERPROFILE') . '/texlive';
} else {
$tex_prefix||='/usr/local/texlive';
}
$vars{'TEXDIRW'}="$tex_prefix/$texlive_release";
$texmfsysvar=getenv('TEXLIVE_INSTALL_TEXMFSYSVAR');
$texmfsysvar||=$vars{'TEXDIRW'} . '/texmf-var';
$vars{'TEXMFSYSVAR'}=$texmfsysvar;
$texmfsysconfig=getenv('TEXLIVE_INSTALL_TEXMFSYSCONFIG');
$texmfsysconfig||=$vars{'TEXDIRW'} . '/texmf-config';
$vars{'TEXMFSYSCONFIG'}=$texmfsysconfig;
$texmflocal=getenv('TEXLIVE_INSTALL_TEXMFLOCAL');
$texmflocal||="$tex_prefix/texmf-local";
$vars{'TEXMFLOCAL'}=$texmflocal;
$vars{'TEXDIR'} = $vars{'from_dvd'} ? abs_path($::installerdir) :
$vars{'TEXDIRW'};
$texmfhome=getenv('TEXLIVE_INSTALL_TEXMFHOME');
$texmfhome ||= "~";
$vars{'TEXMFHOME'}="$texmfhome/texmf";
}
sub calc_depends {
# we have to reset the install hash EVERY TIME otherwise everything will
# always be installed since the default is scheme-full which selects
# all packages and never deselects it
%install=();
my $p;
my $a;
# initialize the %install hash with what should be installed
if ($vars{'selected_scheme'} ne "scheme-custom") {
# First look for packages in the selected scheme.
my $scheme=$tlpdb->get_package($vars{'selected_scheme'});
if (!defined($scheme)) {
if ($vars{'selected_scheme'}) {
# something is written in the selected scheme but not defined, that
# is strange, so warn and die
die ("Scheme $vars{'selected_scheme'} not defined, vars:\n");
dump_vars(\*STDOUT);
}
} else {
for my $scheme_content ($scheme->depends) {
$install{"$scheme_content"}=1 unless ($scheme_content=~/^collection-/);
}
}
}
# Now look for collections in the %vars hash. These are not
# necessarily the collections required by a scheme. The final
# decision is made in the collections/languages menu.
foreach my $key (keys %vars) {
if ($key=~/^collection-/) {
$install{$key} = 1 if $vars{$key};
}
}
# compute the list of archs to be installed
my @archs;
foreach (keys %vars) {
if (m/^binary_(.*)$/ ) {
if ($vars{$_}) { push @archs, $1; }
}
}
#
# work through the addon settings in the %vars hash
if ($vars{'addon_editor'}) {
$install{"texworks"} = 1;
}
# if programs for arch=win32 are installed we also have to install
# tlperl.win32 which provides the "hidden" perl that will be used
# to run all the perl scripts.
# Furthermore we install tlgs.win32 and tlpsv.win32, too
if (grep(/^win32$/, at archs)) {
$install{"tlperl.win32"} = 1;
$install{"tlgs.win32"} = 1;
$install{"tlpsv.win32"} = 1;
}
# loop over all the packages until it is getting stable
my $changed = 1;
while ($changed) {
# set $changed to 0
$changed = 0;
# collect the already selected packages
my @pre_selected = keys %install;
debug("initial number of installations: $#pre_selected\n");
# loop over all the pre_selected and add them
foreach $p (@pre_selected) {
ddebug("pre_selected $p\n");
my $pkg = $tlpdb->get_package($p);
if (!defined($pkg)) {
tlwarn("$p is mentioned somewhere but not available, disabling it.\n");
$install{$p} = 0;
next;
}
foreach my $p_dep ($tlpdb->get_package($p)->depends) {
if ($p_dep =~ m/^(.*)\.ARCH$/) {
my $foo = "$1";
foreach $a (@archs) {
$install{"$foo.$a"} = 1 if defined($tlpdb->get_package("$foo.$a"));
}
} elsif ($p_dep =~ m/^(.*)\.win32$/) {
# a win32 package should *only* be installed if we are installing
# the win32 arch
if (grep(/^win32$/, at archs)) {
$install{$p_dep} = 1;
}
} else {
$install{$p_dep} = 1;
}
}
}
# check for newly selected packages
my @post_selected = keys %install;
debug("number of post installations: $#post_selected\n");
# set repeat condition
if ($#pre_selected != $#post_selected) {
$changed = 1;
}
}
# now do the size computation
my $size = 0;
foreach $p (keys %install) {
my $tlpobj = $tlpdb->get_package($p);
if (not(defined($tlpobj))) {
tlwarn("$p should be installed but "
. "is not in texlive.tlpdb; disabling.\n");
$install{$p} = 0;
next;
}
$size+=$tlpobj->docsize if $vars{'option_doc'};
$size+=$tlpobj->srcsize if $vars{'option_src'};
$size+=$tlpobj->runsize;
foreach $a (@archs) {
$size += $tlpobj->binsize->{$a} if defined($tlpobj->binsize->{$a});
}
}
$vars{'total_size'} =
sprintf "%d", ($size * $TeXLive::TLConfig::BlockSize)/1024**2;
}
sub load_tlpdb {
my $master = $location;
info("Loading $master/$TeXLive::TLConfig::InfraLocation/$TeXLive::TLConfig::DatabaseName\n");
$tlpdb=TeXLive::TLPDB->new(root => "$master");
if (!defined($tlpdb)) {
die "$0: Could not load TeX Live Database from $master, goodbye.\n";
}
# set the defaults to what is specified in the tlpdb
$vars{'option_doc'} = $tlpdb->option("install_docfiles");
$vars{'option_src'} = $tlpdb->option("install_srcfiles");
$vars{'option_fmt'} = $tlpdb->option("create_formats");
$vars{'option_letter'} = defined($tlpdb->option("paper"))
&& ($tlpdb->option("paper") eq "letter" ? 1 : 0);
$vars{'option_desktop_integration'} = $tlpdb->option("desktop_integration");
$vars{'option_desktop_integration'} = 1 if win32();
$vars{'option_path'} = $tlpdb->option("path");
$vars{'option_path'} = 1 if win32();
$vars{'option_w32_multi_user'} = $tlpdb->option("w32_multi_user");
$vars{'option_file_assocs'} = $tlpdb->option("file_assocs");
$vars{'option_post_code'} = $tlpdb->option("post_code");
$vars{'option_sys_bin'} = $tlpdb->option("sys_bin");
$vars{'option_sys_man'} = $tlpdb->option("sys_man");
$vars{'option_sys_info'} = $tlpdb->option("sys_info");
# check that the default scheme is actually present, otherwise switch to
# scheme-minimal
if (!defined($tlpdb->get_package($default_scheme))) {
if (!defined($tlpdb->get_package("scheme-minimal"))) {
die("Aborting, cannot find either $default_scheme or scheme_minimal");
}
$default_scheme = "scheme-minimal";
$vars{'selected_scheme'} = $default_scheme;
}
}
sub initialize_collections {
foreach my $pkg ($tlpdb->list_packages) {
my $tlpobj = $tlpdb->{'tlps'}{$pkg};
if ($tlpobj->category eq "Collection") {
$vars{"$pkg"}=0;
++$vars{'n_collections_available'};
if ($pkg=~/collection-lang/) {
push @collections_lang, $pkg;
} elsif ($pkg=~/documentation/) {
if ($pkg=~/documentation-base/) {
push @collections_std, $pkg;
} else {
push @collections_lang_doc, $pkg;
}
} else {
push @collections_std, $pkg;
}
}
}
my $scheme_tlpobj = $tlpdb->get_package($default_scheme);
if (defined ($scheme_tlpobj)) {
$vars{'n_collections_selected'}=0;
foreach my $dependent ($scheme_tlpobj->depends) {
if ($dependent=~/^(collection-.*)/) {
$vars{"$1"}=1;
++$vars{'n_collections_selected'};
}
}
}
if ($vars{"binary_win32"}) {
$vars{"collection-wintools"} = 1;
++$vars{'n_collections_selected'};
}
}
sub set_install_platform {
my $detected_platform=platform;
if ($opt_custom_bin) {
$detected_platform = "custom";
}
my $warn_nobin;
my $warn_nobin_x86_64_linux;
my $nowarn="";
my $wp='***'; # warning prefix
$warn_nobin="\n$wp WARNING: No binaries for your platform found. ";
$warn_nobin_x86_64_linux="$warn_nobin" .
"$wp No binaries for x86_64-linux found, using i386-linux instead.\n";
my $ret = $warn_nobin;
if (defined $vars{"binary_$detected_platform"}) {
$vars{"binary_$detected_platform"}=1;
$vars{'inst_platform'}=$detected_platform;
$ret = $nowarn;
} elsif ($detected_platform eq 'x86_64-linux') {
$vars{'binary_i386-linux'}=1;
$vars{'inst_platform'}='i386-linux';
$ret = $warn_nobin_x86_64_linux;
} else {
if ($opt_custom_bin) {
$ret = "$wp Using custom binaries from $opt_custom_bin.\n";
} else {
$ret = $warn_nobin;
}
}
foreach my $key (keys %vars) {
if ($key=~/^binary.*/) {
++$vars{'n_systems_selected'} if $vars{$key}==1;
}
}
return($ret);
}
sub create_profile {
my $profilepath = shift;
# The file "TLprofile" is created at the beginning of the
# installation process and contains information about the current
# setup. The purpose is to allow non-interactive installations.
my $fh;
if (ref($profilepath)) {
$fh = $profilepath;
} else {
open PROFILE, ">$profilepath";
$fh = \*PROFILE;
}
my $tim = gmtime(time);
print $fh "# texlive.profile written on $tim UTC\n";
print $fh "# It will NOT be updated and reflects only the\n";
print $fh "# installation profile at installation time.\n";
print $fh "selected_scheme $vars{selected_scheme}\n";
foreach my $key (sort keys %vars) {
print $fh "$key $vars{$key}\n"
if $key=~/^collection/ and $vars{$key}==1;
print $fh "$key $vars{$key}\n" if $key =~ /^option_/;
print $fh "$key $vars{$key}\n" if (($key =~ /^binary_/) && $vars{$key});
print $fh "$key $vars{$key}\n" if $key =~ /^TEXDIR/; # includes TEXDIRW
print $fh "$key $vars{$key}\n" if $key =~ /^TEXMFSYSVAR/;
print $fh "$key $vars{$key}\n" if $key =~ /^TEXMFSYSCONFIG/;
print $fh "$key $vars{$key}\n" if $key =~ /^TEXMFLOCAL/;
print $fh "$key $vars{$key}\n" if $key =~ /^TEXMFHOME/;
print $fh "$key $vars{$key}\n" if $key =~ /^from_dvd/;
}
if (!ref($profilepath)) {
close PROFILE;
}
}
sub read_profile {
my $profilepath = shift;
open PROFILE, "<$profilepath"
or die "$0: Cannot open profile $profilepath for reading.\n";
my %pro;
while (<PROFILE>) {
chomp;
next if m/^[[:space:]]*$/; # skip empty lines
next if m/^[[:space:]]*#/; # skip comment lines
my ($k,$v) = split (" ", $_, 2); # value might have spaces
$pro{$k} = $v;
}
foreach (keys %vars) {
# clear out collections from var
if (m/^collection-/) { $vars{$_} = 0; }
if (defined($pro{$_})) { $vars{$_} = $pro{$_}; }
}
# if a profile contains *only* the selected_scheme setting without
# any collection, we assume that exactely that scheme should be installed
my $coldefined = 0;
foreach my $k (keys %pro) {
if ($k =~ m/^collection-/) {
$coldefined = 1;
last;
}
}
# if at least one collection has been defined return here
return if $coldefined;
# since no collections have been defined in the profile, we
# set those to be installed on which the scheme depends
my $scheme=$tlpdb->get_package($vars{'selected_scheme'});
if (!defined($scheme)) {
dump_vars(\*STDOUT);
die ("Scheme $vars{selected_scheme} not defined.\n");
}
for my $scheme_content ($scheme->depends) {
$vars{"$scheme_content"}=1 if ($scheme_content=~/^collection-/);
}
}
sub prepare_installation {
make_var_skeleton "$vars{'TEXMFSYSVAR'}";
make_local_skeleton "$vars{'TEXMFLOCAL'}";
mkdirhier "$vars{'TEXMFSYSCONFIG'}";
if ($vars{'from_dvd'}) {
$localtlpdb = $tlpdb;
} else {
$localtlpdb=new TeXLive::TLPDB;
$localtlpdb->root("$vars{'TEXDIR'}");
}
}
sub do_install_packages {
my @what;
foreach my $package (sort keys %install) {
push @what, $package if ($install{$package} == 1);
}
if (!install_packages($tlpdb,$media,$localtlpdb,\@what,
$vars{'option_src'},$vars{'option_doc'})) {
my $profile_name = "installation.profile";
create_profile($profile_name);
tlwarn("Installation failed.\n");
tlwarn("Rerunning the installer will try to restart the installation.\n");
tlwarn("Or you can restart by running the installer with:\n");
if (win32()) {
tlwarn(" install-tl.bat --profile $profile_name [EXTRA-ARGS]\n");
} else {
tlwarn(" install-tl --profile $profile_name [EXTRA-ARGS]\n");
}
}
}
# for later complete removal we want to save some options and values
# into the local tlpdb:
# - should links be set, and if yes, the destination (bin,man,info)
sub save_options_into_tlpdb {
$localtlpdb->option ("location", $location);
$localtlpdb->option ("create_formats", $vars{'option_fmt'} ? "1" : "0");
$localtlpdb->option ("desktop_integration", $vars{'option_desktop_integration'} ? "1" : "0");
$localtlpdb->option ("file_assocs", $vars{'option_file_assocs'});
$localtlpdb->option ("post_code", $vars{'option_post_code'} ? "1" : "0");
$localtlpdb->option ("sys_bin", $vars{'option_sys_bin'});
$localtlpdb->option ("sys_info", $vars{'option_sys_info'});
$localtlpdb->option ("sys_man", $vars{'option_sys_man'});
$localtlpdb->option ("install_docfiles", $vars{'option_doc'} ? "1" : "0");
$localtlpdb->option ("install_srcfiles", $vars{'option_src'} ? "1" : "0");
$localtlpdb->option ("w32_multi_user", $vars{'option_w32_multi_user'} ? "1" : "0");
my @archs;
foreach (keys %vars) {
if (m/^binary_(.*)$/ ) {
if ($vars{$_}) { push @archs, $1; }
}
}
if ($opt_custom_bin) {
push @archs, "custom";
}
# only if we forced the platform we do save this option into the tlpdb
if (defined($opt_force_arch)) {
$localtlpdb->setting ("platform", $::_platform_);
}
$localtlpdb->setting("available_architectures", @archs);
$localtlpdb->save() unless $vars{'from_dvd'};
}
sub import_settings_from_old_tlpdb {
# first import the collections
# since the scheme is not the final word we select scheme-custom here
# and then set the single collections by hand
$vars{'selected_scheme'} = "scheme-custom";
$vars{'n_collections_selected'} = 0;
# remove the selection of all collections
foreach my $entry (keys %vars) {
if ($entry=~/^(collection-.*)/) {
$vars{"$1"}=0;
}
}
for my $c ($previoustlpdb->collections) {
my $tlpobj = $tlpdb->get_package($c);
if ($tlpobj) {
$vars{$c} = 1;
++$vars{'n_collections_selected'};
}
}
# now take over the path
my $oldroot = $previoustlpdb->root;
my $newroot = abs_path("$oldroot/..") . "/$texlive_release";
$vars{'TEXDIR'} = $newroot;
$vars{'TEXDIRW'} = $newroot;
$vars{'TEXMFSYSVAR'} = "$newroot/texmf-var";
$vars{'TEXMFSYSCONFIG'} = "$newroot/texmf-config";
# only TEXMFLOCAL is treated differently, we use what is found by kpsewhich
# in 2008 and onward this is defined as
# TEXMFLOCAL = $SELFAUTOPARENT/../texmf-local
# so kpsewhich -var-value=TEXMFLOCAL returns
# ..../2008/../texmf-local
# TODO TODO TODO
chomp (my $tml = `kpsewhich -var-value=TEXMFLOCAL`);
$tml = abs_path($tml);
$vars{'TEXMFLOCAL'} = $tml;
#
# now for the settings
# set the defaults to what is specified in the tlpdb
$vars{'option_doc'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"install_docfiles");
$vars{'option_src'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"install_srcfiles");
$vars{'option_fmt'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"create_formats");
$vars{'option_desktop_integration'} = 1 if win32();
# option_path does not exist in older installation
$vars{'option_path'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"create_symlinks");
$vars{'option_path'} = 1 if win32();
$vars{'option_sys_bin'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"sys_bin");
$vars{'option_sys_man'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"sys_man");
$vars{'sys_info'} =
$previoustlpdb->option_pkg("00texlive-installation.config",
"sys_info");
#
# import the set of selected architectures
my @aar = $previoustlpdb->setting_pkg("00texlive-installation.config",
"available_architectures");
if (@aar) {
for my $b ($tlpdb->available_architectures) {
$vars{"binary_$b"} = member( $b, @aar );
}
$vars{'n_systems_available'} = 0;
for my $key (keys %vars) {
++$vars{'n_systems_available'} if ($key=~/^binary/);
}
}
}
# do everything to select a scheme
#
sub select_scheme {
my $s = shift;
# set the selected scheme to $s
$vars{'selected_scheme'} = $s;
# if we are working on scheme-custom simply return
return if ($s eq "scheme-custom");
# remove the selection of all collections
foreach my $entry (keys %vars) {
if ($entry=~/^(collection-.*)/) {
$vars{"$1"}=0;
}
}
# select the collections belonging to the scheme
my $scheme_tlpobj = $tlpdb->get_package($s);
if (defined ($scheme_tlpobj)) {
$vars{'n_collections_selected'}=0;
foreach my $dependent ($scheme_tlpobj->depends) {
if ($dependent=~/^(collection-.*)/) {
$vars{"$1"}=1;
++$vars{'n_collections_selected'};
}
}
}
# we have first set all collection-* keys to zero and than
# set to 1 only those which are required by the scheme
# since now scheme asks for collection-wintools we set its vars value
# to 1 in case we are installing win32 binaries
if ($vars{"binary_win32"}) {
$vars{"collection-wintools"} = 1;
++$vars{'n_collections_selected'};
}
# for good measure, update the deps
calc_depends();
}
sub update_numbers {
$vars{'n_collections_available'}=0;
$vars{'n_collections_selected'} = 0;
$vars{'n_systems_available'} = 0;
$vars{'n_systems_selected'} = 0;
foreach my $key (keys %vars) {
if ($key =~ /^binary/) {
++$vars{'n_systems_available'};
++$vars{'n_systems_selected'} if $vars{$key} == 1;
}
if ($key =~ /^collection-/) {
++$vars{'n_collections_available'};
++$vars{'n_collections_selected'} if $vars{$key} == 1;
}
}
}
sub flushlog {
my $fh;
if (open(LOG,">install-tl.log")) {
warn "Writing log file to current working directory.\n";
$fh = \*LOG;
} else {
$fh = \*STDERR;
warn "Not creating a log file but flushing messages to stderr.\n";
}
foreach my $l (@::LOGLINES) {
print $fh $l;
}
}
sub check_on_lang_collection_installed {
# we check that at least one lang collection is installed:
foreach my $c (@collections_lang) {
return 1 if $vars{"$c"};
}
if ($vars{"selected_scheme"} eq "scheme-context") {
# context
return 1;
}
return 0;
}
sub do_cleanup
{
# now open the log file and write out the log lines
# try to open a log file
# the user could have given the -logfile option in which case all the
# stuff is already dumped to it and $::LOGFILE defined. So do not
# redefine it
if (!defined($::LOGFILE)) {
if (open(LOGF,">$vars{'TEXDIRW'}/install-tl.log")) {
$::LOGFILE = \*LOGF;
foreach my $line(@::LOGLINES) {
print $::LOGFILE "$line";
}
} else {
tlwarn("$0: Cannot create log file $vars{'TEXDIRW'}/install-tl.log: $!\n"
. "Not writing out log lines.\n");
}
}
# remove temporary files from TEXDIR/temp
if (($media eq "CD") or ($media eq "NET")) {
debug("Remove temporary downloaded containers...\n");
rmtree("$vars{'TEXDIRW'}/temp") if (-d "$vars{'TEXDIRW'}/temp");
}
# dump various things to the log file
#if (defined($::LOGFILE)) {
# print $::LOGFILE "\nDump of vars:\n";
# foreach my $key (keys %vars) {
# print $::LOGFILE "$key $vars{$key}\n";
# }
# create_profile($::LOGFILE);
#}
# should not be needed any more
#dump_vars("$system_tmpdir/texlive.vars");
# write the profile out
if ($vars{'from_dvd'}) {
create_profile("$vars{'TEXDIRW'}/texlive.profile");
debug("Profile written to $vars{'TEXDIRW'}/texlive.profile\n");
} else {
create_profile("$vars{'TEXDIR'}/$InfraLocation/texlive.profile");
debug("Profile written to $vars{'TEXDIR'}/$InfraLocation/texlive.profile\n");
}
# Close log file if present
close($::LOGFILE) if (defined($::LOGFILE));
if (defined($::LOGFILENAME) and (-e $::LOGFILENAME)) {
print "Logfile: $::LOGFILENAME\n";
} elsif (-e "$vars{'TEXDIRW'}/install-tl.log") {
print "Logfile: $vars{'TEXDIRW'}/install-tl.log\n";
} else {
print "No logfile\n";
}
}
# portable option, invoked from tl-portable script.
#
sub do_portable {
$::opt_verbosity = -1;
$::_platform_ = platform();
$location = getenv('TEXDIR');
die "$0: Don't use --portable directly; use tl-portable instead\n"
unless $location;
$vars{'TEXDIR'} = $location;
if (not -d $vars{'TEXDIR'}.'/bin/'.$::_platform_) { # shouldn't happen
die "$0: Platform ".$::_platform_." not supported.";
}
# set_platforms_supported();
# set_texlive_default_dirs();
$vars{'TEXDIRW'} = getenv('TEXDIRW');
$vars{'TEXMFSYSVAR'} = getenv('TEXMFSYSVAR');
$vars{'TEXMFSYSCONFIG'} = getenv('TEXMFSYSCONFIG');
$vars{'TEXMFLOCAL'} = getenv('TEXMFLOCAL');
$vars{'TEXMFHOME'} = getenv('TEXMFHOME');
$vars{'TEXMFVAR'} = getenv('TEXMFVAR');
$vars{'TEXMFCONFIG'} = getenv('TEXMFCONFIG');
if (win32()) {
non_admin();
my $winpath = "$vars{'TEXDIR'}/bin/win32";
}
our $PORTABLE_PROMPT_DONE = 0; # used in subroutine below
if (! -d "$vars{'TEXMFCONFIG'}" ) {
portable_prompt ();
mkdirhier "$vars{'TEXMFCONFIG'}";
}
if (! -d "$vars{'TEXMFSYSCONFIG'}" ) {
portable_prompt ();
mkdirhier "$vars{'TEXMFSYSCONFIG'}";
}
if (! -d "$vars{'TEXMFSYSVAR'}" ) {
portable_prompt ();
load_tlpdb();
$localtlpdb = $tlpdb;
$texlive_release = $tlpdb->config_release;
make_var_skeleton "$vars{'TEXMFSYSVAR'}";
# the usual option for pregenerating all formats doesn't apply
$vars{'option_fmt'} = 0;
do_postinst_stuff();
}
close($::LOGFILE) if defined($::LOGFILE);
print TeXLive::TLUtils::welcome;
exit 0;
# Give the user a chance to bail before changing anything.
# (Nested subroutine.)
sub portable_prompt
{
return if $PORTABLE_PROMPT_DONE;
$PORTABLE_PROMPT_DONE = 1;
print "About to generate some files, press Enter to continue:";
<STDIN>;
}
}
#
# some helper fucntion
sub select_collections {
my $varref = shift;
foreach (@_) {
$varref->{$_} = 1;
}
}
sub deselect_collections {
my $varref = shift;
foreach (@_) {
$varref->{$_} = 0;
}
}
__END__
=head1 NAME
install-tl - TeX Live cross-platform installer
=head1 SYNOPSIS
install-tl [OPTION]...
install-tl.bat [OPTION]...
=head1 DESCRIPTION
The TeX Live installer works across all supported platforms and allows
to install TeX Live from various media, including the network.
Post-installation configuration, packages updates, and more, are now
available through B<tlmgr>(1), the TeX Live Manager
(L<http://tug.org/texlive/tlmgr.html>).
The most up-to-date version of this documentation is on the Internet at
L<http://tug.org/texlive/doc/install-tl.html>.
=head1 OPTIONS
=over 4
=item B<-gui> [[=]I<module>]
If no I<module> is given starts the default GUI installer (default on
Windows).
If I<module> is given loads the given installer module. Currently the
following modules are supported:
=over 8
=item C<text>
The text mode user interface which is the default on Unix systems, and
can be forced with by giving C<text> as I<module>, or with the C<-no-gui>
switch.
=item C<wizard>
The wizard mode user interface asking only a few questions before installing
all of TeX Live. This is the default on Windows systems.
=item C<perltk>
The all-in-one GUI installer.
It can also be selected by giving the C<-gui> option without any I<module>.
=back
The C<perltk> and C<wizard> modules, and thus also when calling with a
simple C<-gui> (without I<module>) requires
the Perl/Tk module (L<http://tug.org/texlive/distro.html#perltk>; if
Perl/Tk is not available, installation continues in text mode.
=item B<-no-gui>
Use the text mode installer (default except on Windows).
=item B<-lang> I<2-letter lang code>
(only for GUI installer) If possible, start the installer translated into
the language specified by the 2-letter language code. Currently supported
languages: English (en, default), German (de), French (fr), Dutch (nl),
Polish (pl) and Slovenian (sl).
=item B<-location> I<url|path>
Provide an installation source, either a local directory via
C</path/to/directory> or a C<file:/> url, or a network location via
a C<http://> or C<ftp://> url.
If the location is local, the installation type (compressed or live) is
automatically determined, by checking for the presence of a
C<archive> directory relative to the root. Compressed is
preferred if both are available, since it is faster. Here's an example
of using a local directory:
-location /local/TL/repository/copy
If the location is on the network, trailing C</> characters and/or
trailing C</tlpkg> and C</archive> components are ignored. For example,
you could choose a particular CTAN mirror with something like this:
-location http://mirror.example.org/path/to/ctan/texlive/tlnet/2008
Of course a proper hostname and its particular top-level CTAN path
have to be specified. (The list of CTAN mirrors is maintained at
L<http://ctan.org/mirrors>.)
The default is to pick a mirror automatically, using
L<http://mirror.ctan.org/systems/texlive/tlnet/YYYY>; the chosen mirror
is used for the entire download. You can use the special location name
C<ctan> as an abbreviation for this. See L<http://ctan.org> for more
about CTAN and its mirrors.
After installation is complete, you can use that installation as the
location for another installation. If you chose to install less than
the full scheme containing all packages, the list of available schemes
will be adjusted accordingly.
=item B<-no-cls>
(only for text mode installer) do not clear the screen when entering
a new menu (for debugging purposes).
=item B<-non-admin>
For Windows only: configure for the current user, not for all users.
=item B<-portable>
Start the installer for portable use---but use the C<tl-portable>
scripts instead of this option. See below for details.
=item B<-print-arch>
Print the detected arch-os combination and exit.
=item B<-force-arch> I<arch-os>
Instead of auto-detecting the current platform use the one given on the
cmd line. Make sure that there are binaries for this platform and they
can actually be run.
=item B<-profile> I<profile>
Load the I<profile> file for repeated installations on different systems.
A I<profile> contains the values of all necessary variable for the
installation. After normal installation has finished a profile for that
exact installation is written into DEST/tlpkg/texlive.profile. That file
can be used to do the exact same installation on a different computer.
You can also hand-craft such a profile starting from a generated one
by changing some values. Normally a profile has to contain the value 1 for
each collection that should be installed, even if the scheme is specified.
That follows from the logic of the installer that you first select a scheme
and then can change the actual collections being installed.
There is one exception to this: If the profile contains a variable for
B<selected_scheme> and I<no> collection variable is defined in the
profile, then the collections which the specified scheme requires are
installed. Thus, a simple line C<selected_scheme scheme-medium>
together with the definitions of the paths (C<TEXDIR>, C<TEXDIRW>,
C<TEXMFHOME>, C<TEXMFLOCAL>, C<TEXMFSYSCONFIG>, C<TEXMFSYSVAR>) suffices
to install the medium scheme with all default options.
=item B<-scheme> I<scheme>
Schemes are the highest level of package grouping in TeX Live; the
default is to use the C<full> scheme, which includes everything. This
option overrides that default. You can change the scheme again before
the actual installation with the usual menu. The I<scheme> argument may
optionally have a prefix C<scheme->. The list of supported scheme names
depends on what your installation location provides; see the interactive
menu list.
=item B<-custom-bin> I<path>
In case your architecture is not supported by TeX Live out of the box
and you have built your own binaries for your system, this option allows
to give the I<path> to a directory where ready made binaries for your
system are present. The installation will continue as normally, but at
the end all files from I<path> are copied over to C<bin/custom> in your
installation folder and this directory will be added to the path for
the postinstall actions.
=item B<-q>
Omit normal informational messages.
=item B<-v>
Include debugging messages; repeat for maximum debugging, as in C<-v
-v>. (Further repeats are accepted but ignored.)
=item B<-logfile> I<file>
Write both all messages (informational, debugging, warnings) to I<file>,
in addition to standard output or standard error.
If this option is not given, the installer will create a log file
in the root of the writable installation tree,
for example, C</usr/local/texlive/YYYY/install-tl.log> for the I<YYYY>
release.
=item B<--help>, B<-help>, B<-?>
Display this help and exit.
=item B<--version>, B<-version>
Output version information and exit.
=back
As usual, all options can be specified with either C<-> or C<-->, and
arguments can be be separated from their options by either a space or C<=>.
=head1 PORTABLE USE
The TeX Live root directory contains a shell script C<tl-portable.sh>
and a DOS batch file C<tl-portable.bat> which start up a new shell and
command prompt in which TeX Live can be run with minimal impact on the
host system. These files start up C<install-tl> with the
C<-portable> option for some minimal preparation. Don't use this option
directly; it makes very specific assumptions about its environment.
=head1 AUTHORS AND COPYRIGHT
This script and its documentation were written for the TeX Live
distribution (L<http://tug.org/texlive>) and both are licensed under the
GNU General Public License Version 2 or later.
=cut
### Local Variables:
### perl-indent-level: 2
### tab-width: 2
### indent-tabs-mode: nil
### End:
# vim:set tabstop=2 expandtab: #
-------------- next part --------------
A non-text attachment was scrubbed...
Name: TLUtils.pm
Type: text/x-perl
Size: 86431 bytes
Desc: not available
URL: <http://tug.org/pipermail/tex-live/attachments/20090708/a6eeab43/attachment-0002.bin>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: TLWinGoo.pm
Type: text/x-perl
Size: 28565 bytes
Desc: not available
URL: <http://tug.org/pipermail/tex-live/attachments/20090708/a6eeab43/attachment-0003.bin>
More information about the tex-live
mailing list