/
INSTALL.txt
250 lines (186 loc) · 9.61 KB
/
INSTALL.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
Installing Modules-Tcl on Unix
==============================
This document is an overview of building and installing Modules-Tcl on a Unix
system.
Requirements
------------
Modules-Tcl consists of one Tcl script so to run it from a user shell the only
requirement is to have a working version of `tclsh` available on your system.
`tclsh` is a part of Tcl (http://www.tcl.tk/software/tcltk/).
To install Modules-Tcl from a distribution tarball or a clone of the git
repository, a build step is there to adapt the initialization scripts to your
configuration and create the documentation files. This build step requires
the tools to be found on your system:
* sh
* make
* perl
* grep
* cut
* pod2text
* pod2man
* runtest
Installation instructions
-------------------------
The simplest way to build and install Modules-tcl is:
$ ./configure
$ make
$ make install
Some explanation, step by step:
0. `cd' to the directory containing the package's source code. Your system
must have the above requirements installed to properly build init scripts
and documentation.
1. Type `./configure' to adapt the installation for your system. At this step
you can choose the installation paths and the features you want to enable
in the initialization scripts (see "Build and installation options" section
below for a complete overview of the available options)
2. Type `make' to adapt scripts to the configuration and build documentation.
3. Optionally, type `make check' to run the test suite.
4. Type `make install' to install modulecmd.tcl, initialization scripts and
documentation.
5. You can remove the built files from the source code directory by typing
`make clean'. To also remove the files that `configure' created, type
`make distclean'.
A default installation process like described above will install Modules-tcl
under `/usr/local/modules-tcl'. You can change this with the `--prefix'
option. By default, `/usr/local/modules-tcl/modulefiles' will be setup as the
default directory containing modulefiles. `--modulefilesdir' option enables to
change this directory location. For example:
$ ./configure --prefix=/usr/share/modules-tcl \
--modulefilesdir=/etc/modulefiles
See "Build and installation options" section to discover all `./configure'
option available.
Configuration
-------------
Once installed you should review and adapt the configuration to make it fit
your needs. The following steps are provided for example. They are not
necessarily mandatory as it depends of the kind of setup you want to achieve.
1. Tune the initialization scripts. Review of these scripts is highly
encouraged as you may add or adapt specific stuff to get Modules
initialized the way you want.
2. Enable Modules initialization at shell startup. An easy way to get module
function defined and its associated configuration setup at shell startup
is to make the initialization scripts part of the system-wide environment
setup in `/etc/profile.d'. To do so, make a link in this directory to the
profile scripts that can be found in your Modules installation init
directory:
$ ln -s PREFIX/init/profile.sh /etc/profile.d/modules.sh
$ ln -s PREFIX/init/profile.csh /etc/profile.d/modules.csh
These profile scripts will automatically adapt to the kind of `sh' or
`csh' shell you are running.
Another approach may be to get the Modules initialization script sourced
from the shell configuration startup file. For instance following line
could be added to the end of the `~/.bashrc' file if running Bash shell:
source PREFIX/init/bash
Beware that shells have multiple ways to initialize depending if they are
a login shell or not and if they are launched in interactive mode or not.
3. Define module paths to enable by default. Edit `modulerc' configuration
file or `.modulespath' if you have chosen `--enable-dotmodulespath' at
configure time. Add there all the modulefile directories you want to
activate by default at Modules initialization time.
If you use `.modulespath' configuration file, add one line mentioning
each modulefile directory:
/path/to/regular/modulefiles
/path/to/other/modulefiles
If you use `modulerc' configuration file, add one line mentioning each
modulefile directory prefixed by the `module use' command:
module use /path/to/regular/modulefiles
module use /path/to/other/modulefiles
4. Define modulefiles to load by default. Edit `modulerc' configuration file
(modulefiles to load cannot be specified in `.modulespath' file). Add
there all the modulefiles you want to load by default at Modules
initialization time.
Add one line mentioning each modulefile to load prefixed by the
`module load' command:
module load foo
module load bar
In fact you can add to the `modulerc' configuration file any kind of
supported module command.
If you go through the above steps you should have a valid setup tuned to your
needs. After that you still have to write modulefiles to get something to load
and unload in your newly configured Modules setup. Please have a look at the
`doc/example.txt' that explains how the user environment is setup with Modules
at the University of Minnesota computer science department.
Build and installation options
------------------------------
Options available at the `./configure' installation step are described below.
These options enable to choose the installation paths and the features to
enable or disable. You can also get a description of these options by typing
`./configure --help'.
Fine tuning of the installation directories (the default value for each option
is displayed within brakets):
--prefix=PREFIX [/usr/local/modules-tcl]
Installation root directory
--bindir=DIR [PREFIX/bin]
Directory for executables reachable by users
--libexecdir=DIR [PREFIX/libexec]
Directory for executables called by other executables like modulecmd.tcl
--initdir=DIR [PREFIX/init]
Directory for the per-shell environment initialization scripts
--datarootdir=DIR [PREFIX/share]
Base directory to set the man and doc directories
--mandir=DIR [DATAROOTDIR/man]
Directory to host man pages
--docdir=DIR [DATAROOTDIR/doc]
Directory to host documentation other than man pages like README, license
file, etc
--modulefilesdir=DIR [PREFIX/modulefiles]
Directory or main modulefiles also called system modulefiles
Optional Features (a (*) mark is set to highlight the default value):
--disable-set-manpath
--enable-set-manpath (*)
Prepend man page directory defined by the `--mandir' option to the
MANPATH environment variable in the shell initialization scripts.
--disable-set-binpath
--enable-set-binpath (*)
Prepend binary directory defined by the `--bindir' option to the PATH
environment variable in the shell initialization scripts.
--disable-set-switchml
--enable-set-switchml (*)
Define the `switchml' shell function or alias in the shell initialization
scripts. This option requires to know where the initialization scripts of
the C version can be found, which means `--with-cver-initdir' has to be
defined.
--disable-dotmodulespath (*)
--enable-dotmodulespath
Set the module paths defined by `--with-modulepath' option in a
`.modulespath' file (following C version fashion) within the
initialization directory defined by the `--initdir' option rather than
within the `modulerc' file.
--disable-use-cver-dotmodulespath (*)
--enable-use-cver-dotmodulespath
Bind the `.modulespath' configuration file to the .modulespath sets for
the installed Modules C version. Bond is achieved with a symbolic link.
This option requires to know where the initialization scripts of the C
version can be found, which means `--with-cver-initdir' has to be
defined. Moreover enabling this option super-seeds the value set to the
`--enable-dotmodulespath' option.
Optional Packages (a (*) mark is set to highlight the default value):
--without-cver-initdir (*)
--with-cver-initdir=DIR
Installed Modules C version directory for the per-shell environment
initialization scripts. This option is required when setting the
`--enable-set-switchml' and the `--enable-use-cver-dotmodulespath'
options
--without-cver-bindir (*)
--with-cver-bindir=DIR
Installed Modules C version directory for executables reachable by users.
This option is useful to the `--enable-set-switchml' option to switch
Modules-related binary directory when switching Modules version
--without-cver-mandir (*)
--with-cver-mandir=DIR
Installed Modules C version directory that hosts man pages. This option
is useful to the `--enable-set-switchml' option to switch Modules-related
man page directory when switching Modules version
--without-modulepath
--with-modulepath=PATHLIST (*) [PREFIX/modulefiles]
Default path list to setup as the default modulepaths. Each path in this
list should be separated by `:'. Defined value is registered in the
`modulerc' or `.modulespath' configuration file, depending on the
`--enable-dotmodulespath' option. This value is read at initialization
time to populate the MODULEPATH environment variable. By default, this
modulepath is composed of the directory set for the system modulefiles
--without-loadedmodules (*)
--with-loadedmodules=MODLIST
Default modulefiles to load at Modules initialization time. Each
modulefile in this list should be separated by `:'. Defined value is
registered in the `modulerc' configuration file.