Man Linux: Main Page and Category List


       gpt-build - Builds and installs GPT source packages and bundles.


       gpt-build [options] [macros] [source packages] flavors ...

            -verbose                          Print copious output
            -help                             Print usage
            -man                              Print man page.
            -version                          Print GPT version.
            -installdir=path_to_installation  Override $GLOBUS_LOCATION
            -builddir=path_to_build directory Directory to unpack tarfiles
            -logdir=log_file_directory        Directory for package logs
            -srcdir=source_directory          Directory containing a source package
            -static                           Build static executables
            -force                            Force rebuilds
            -update                           Rebuild if newer
            -disable-version-checking         Ignore versions in package dependencies.
            -std-flavors                      Build all std flavors.
            -all-flavors                      Build all of the flavors
            -coresrc                          Override installed globus_core pkg
            -nosrc                            Only install the flavors
            [macro=value]                     Macro definitions
            [list of flavors to build]        Flavors that define the build options
            [list of source packages]         Tarfiles of source bundles or packages


       gpt-build Builds and installs software from source distributions.  The
       script reads the build instructions for each source distribution from a
       package metadata file called pkg_data_src.gpt.  If no instructions are
       found the script uses the default instructions described in

       Multiple packages can be built by passing in multiple -srcdir arguments
       or multiple source packages and or bundles.  For now these have to be
       passed in in dependent order ie. if package foo needs package fee’s
       headers to build then fee should come first.

       gpt-build does not create binary packages as globus-build does.  This
       is done by a seperate script called gpt-pkg.


       Build flavors are character string labels that represent a set of
       compiler and linker options defined during the building of the
       globus_core package. Predefined flavors can be listed by using the gpt-
       flavor-configuration script.  Packages can be built with any installed
       flavor.  globus_core can only be built with pre-defined flavors.
       globus_core needs to be built by hand (i.e. ./configure|make|make
       install) to install a custom build flavor.


       Installed files such as executables that are found in pgm and
       ptm_static packages will overwrite one another when multiple flavors of
       the same package are built.  Thus only the files from the last flavor
       built will be present after a gpt-build run. To preserve multiple
       flavors of these files, they are automatically copied into flavored
       subdirectories.  For example, the program $GLOBUS_LOCATION/bin/foo will
       be copied into the location $GLOBUS_LOCATION/bin/gcc32/shared if it was
       built with dynamically with the gcc32 flavor.  These files are
       retrieved by gpt-pkg.


       -srcdir Specifies the where the source directory is.  This is used by
               developers to build out of a repository..

               Specifies the where the install directory is.  This directory
               will be where the targets are installed before being archived.
               Note that this directory needs contain the installation targets
               of all of the packages which satisfy build dependencies in
               addition to the installation targets of the package being
               built.  Because of this, installation targets are not removed
               after the package is archived.  Because different flavors of
               program packages conflict with each other, the last flavor
               built is the flavor of the installed files.  For each flavor,
               gpt-build makes a copy of each installed file in a program
               package and puts the copy in a flavored subdirectory.

               Specifies the where the source tar files should be untarred and
               the code is built.

       -force  Tells gpt-build to rebuild a package even if it is already
               installed.  The default behavior is to skip any packages that
               have been built before.

       -update Tells gpt-build to build even if an older version is installed.

               Prints out all of the build messages.

               Build the globus_core package with all of the flavor choices
               marked as standard in the flavor configuration file.  All of
               the other packages will be built with all of the flavors
               sucessfully installed by globus_core.

               Build the globus_core package with all of the flavor choices
               marked as standard in the flavor configuration file.  All of
               the other packages will be built with all of the flavors
               sucessfully installed by globus_core.

       -nosrc  Just install the listed flavors.  Don’t build any source code.

               Use this version of globus_core source rather than the one
               found in $GPT_LOCATION/share/globus/globus_core-src.tar.gz.

               GPT 1.x scripts neglected to check the version numbers of
               packages during dependency checks.  Because of this GPT bundles
               were released that have errors in their dependency data.  This
               flag is provided so that these packages can still be used.
               NOTE that once this flag is used, the version checking is
               disabled permanently for the installation pointed to by
               $GLOBUS_LOCATION.  This condition can only be removed by
               deleting the file

               Use the flavor configurations found in FILE.  The default
               configuration file is

               Store package logs of build messages in DIRECTORY. This option
               also sets -verbose. The default directory is ./logs.

       -help   Print a brief help message and exits.

       -man    Prints the manual page and exits.

               Prints the version of GPT and exits.


       Build macros are perl routines and variables that are used by gpt-build
       while building packages.  These macros are embedded in the build
       instructions part of the package’s metadata file.  Some of these macros
       can be set from the command line using the following format:

         <NAME>_GPTMACRO='new value'

       Note that even though this feature seems extremely flexible, it has not
       been thoroughly tested mainly because the authors have not been able to
       figure out what people will want to do with these macros.  Further
       details are found in the Grid::GPT::PkgMngmt::BuildMacros manpage.


       gpt-pkg(8) gpt-bundle(8) gpt-install(8) BuildMacros(3)


       Michael Bletzinger <> and Eric Blau