| 227 |
dpurdie |
1 |
#! perl
|
|
|
2 |
########################################################################
|
|
|
3 |
# Copyright (C) 1998-2004 ERG Limited, All rights reserved
|
|
|
4 |
#
|
|
|
5 |
# Module name : jats.sh
|
|
|
6 |
# Module type : Makefile system
|
|
|
7 |
# Compiler(s) : n/a
|
|
|
8 |
# Environment(s): jats
|
|
|
9 |
#
|
|
|
10 |
# Description:
|
|
|
11 |
# This is a wrapper script to simplify access to the jats
|
|
|
12 |
# build system
|
|
|
13 |
#
|
|
|
14 |
# Usage: jats build | make | install | help | ...
|
|
|
15 |
#
|
| 229 |
dpurdie |
16 |
# Package: PACKAGE_TAG
|
|
|
17 |
# Version: VERSION_TAG
|
| 227 |
dpurdie |
18 |
#......................................................................#
|
|
|
19 |
|
| 261 |
dpurdie |
20 |
require 5.008_002;
|
| 227 |
dpurdie |
21 |
use strict;
|
|
|
22 |
use warnings;
|
|
|
23 |
|
|
|
24 |
use Cwd;
|
|
|
25 |
use File::Copy;
|
|
|
26 |
use Getopt::Long qw(:config require_order); # Stop on non-option
|
|
|
27 |
use Pod::Usage; # For help support
|
|
|
28 |
use FindBin; # Determine the current directory
|
|
|
29 |
use lib "$FindBin::Bin/LIB"; # Allow JATS libraries
|
|
|
30 |
use Config;
|
|
|
31 |
use Sys::Hostname; # For hostname
|
|
|
32 |
|
|
|
33 |
use JatsError; # Common error reporting
|
|
|
34 |
use DescPkg; # Package Descriptor processing
|
|
|
35 |
use JatsSystem; # System call interface
|
| 245 |
dpurdie |
36 |
use JatsBuildFiles; # Parse Build Files
|
| 227 |
dpurdie |
37 |
|
| 229 |
dpurdie |
38 |
my $GBE_VERSION = "VERSION_TAG"; # Will be re-written when released
|
| 245 |
dpurdie |
39 |
my $GBE_NOT_RELEASED = "RELEASE_TAG"; # Will be re-written when released
|
| 227 |
dpurdie |
40 |
my $opr_done;
|
|
|
41 |
my $opt_here = 0;
|
|
|
42 |
my $BUILD_FILE = "build.pl";
|
|
|
43 |
my @BUILD_FILE_ALT = qw(auto.pl build_test.pl);
|
|
|
44 |
my $BUILD_FILE_SET;
|
|
|
45 |
my $RESULT = 0;
|
|
|
46 |
my $PSPLIT = ':'; # Win/Unix path splitter
|
|
|
47 |
my $TIMER = time;
|
|
|
48 |
my $opt_time = 0;
|
|
|
49 |
my $opt_help = 0;
|
|
|
50 |
my $opt_locate = 0;
|
|
|
51 |
my $opt_locate_file;
|
| 245 |
dpurdie |
52 |
my $opt_locate_package;
|
| 227 |
dpurdie |
53 |
my $opt_dir;
|
|
|
54 |
my $opt_java;
|
| 277 |
dpurdie |
55 |
my $opt_export_vars = 1;
|
| 227 |
dpurdie |
56 |
my $result;
|
|
|
57 |
|
|
|
58 |
#
|
|
|
59 |
# Grab a copy of ALL the environment variable that will be used
|
|
|
60 |
# This will simplify the script a great deal
|
|
|
61 |
#
|
|
|
62 |
|
| 279 |
dpurdie |
63 |
our $GBE_JATS_VERSION = $ENV{'GBE_JATS_VERSION'} || '';
|
| 227 |
dpurdie |
64 |
our $GBE_JATS_SANE = $ENV{'GBE_JATS_SANE'} || 0;
|
| 279 |
dpurdie |
65 |
our $GBE_CORE = $ENV{'GBE_CORE'} || '';
|
|
|
66 |
our $GBE_BIN = $ENV{'GBE_BIN'} || '';
|
|
|
67 |
our $GBE_CONFIG = $ENV{'GBE_CONFIG'} || '';
|
|
|
68 |
our $GBE_DPLY = $ENV{'GBE_DPLY'} || '';
|
|
|
69 |
our $GBE_DPKG = $ENV{'GBE_DPKG'} || '';
|
|
|
70 |
our $GBE_DPKG_STORE = $ENV{'GBE_DPKG_STORE'} || '';
|
|
|
71 |
our $GBE_DPKG_LOCAL = $ENV{'GBE_DPKG_LOCAL'} || '';
|
|
|
72 |
our $GBE_DPKG_CACHE = $ENV{'GBE_DPKG_CACHE'} || '';
|
|
|
73 |
our $GBE_DPKG_SBOX = $ENV{'GBE_DPKG_SBOX'} || '';
|
|
|
74 |
our $GBE_SANDBOX = $ENV{'GBE_SANDBOX'} || '';
|
|
|
75 |
our $GBE_PERL = $ENV{'GBE_PERL'} || '';
|
|
|
76 |
our $GBE_TOOLS = $ENV{'GBE_TOOLS'} || '';
|
|
|
77 |
our $GBE_MACHTYPE = $ENV{'GBE_MACHTYPE'} || '';
|
| 273 |
dpurdie |
78 |
our $GBE_HOSTMACH = $ENV{'GBE_HOSTMACH'} || $GBE_MACHTYPE;
|
| 279 |
dpurdie |
79 |
our $GBE_PLATFORM = $ENV{'GBE_PLATFORM'} || '';
|
|
|
80 |
our $GBE_BUILDFILTER = $ENV{'GBE_BUILDFILTER'} || '';
|
| 227 |
dpurdie |
81 |
our $GBE_DEBUG = $ENV{'GBE_DEBUG'} || 0;
|
|
|
82 |
our $GBE_VERBOSE = $ENV{'GBE_VERBOSE'} || 0;
|
| 279 |
dpurdie |
83 |
our $GBE_DRV = $ENV{'GBE_DRV'} || '';
|
|
|
84 |
our $GBE_HOSTNAME = $ENV{'GBE_HOSTNAME'} || hostname || '';
|
|
|
85 |
our $USER = $ENV{'USER'} || '';
|
|
|
86 |
our $PERL5LIB = $ENV{'PERL5LIB'} || '';
|
|
|
87 |
our $JAVA_HOME = $ENV{'JAVA_HOME'} || '';
|
|
|
88 |
our $GBE_ABT = $ENV{'GBE_ABT'} || '';
|
| 227 |
dpurdie |
89 |
our $GBE_UNIX = 1;
|
|
|
90 |
our $CWD;
|
|
|
91 |
|
|
|
92 |
#-------------------------------------------------------------------------------
|
|
|
93 |
# Clean up some environment variables
|
| 245 |
dpurdie |
94 |
# GBE_BUILDFILTER - may be space or comma separated list
|
|
|
95 |
# GBE_PLATFORM - may be space or comma separated list
|
|
|
96 |
# GBE_ABT - may be space or comma separated list
|
| 279 |
dpurdie |
97 |
# GBE_HOSTNAME - No whitespace
|
| 227 |
dpurdie |
98 |
#
|
|
|
99 |
$GBE_BUILDFILTER = join (' ', split( /[,\s]+/, $GBE_BUILDFILTER));
|
|
|
100 |
$GBE_PLATFORM = join (' ', split( /[,\s]+/, $GBE_PLATFORM));
|
|
|
101 |
$GBE_ABT = join (' ', split( /[,\s]+/, $GBE_ABT));
|
| 279 |
dpurdie |
102 |
$GBE_HOSTNAME =~ s~\s+~~g;
|
| 227 |
dpurdie |
103 |
|
|
|
104 |
#-------------------------------------------------------------------------------
|
|
|
105 |
# Parse the user options
|
|
|
106 |
# GetOptions has been configured so that it will stop parsing on the first
|
|
|
107 |
# non-options. This allows the command syntax to the script to have options
|
|
|
108 |
# that are directed to this script before the command keyword, and command
|
|
|
109 |
# options to the subcommand to be after the keyword.
|
|
|
110 |
#
|
|
|
111 |
$result = GetOptions (
|
| 261 |
dpurdie |
112 |
"help|h:+" => \$opt_help,
|
|
|
113 |
"manual:3" => \$opt_help,
|
|
|
114 |
"verbose|v:+" => \$GBE_VERBOSE,
|
|
|
115 |
"debug:+" => \$GBE_DEBUG,
|
| 227 |
dpurdie |
116 |
"cd|changedir=s" => \$opt_dir,
|
|
|
117 |
"locate" => \$opt_locate,
|
|
|
118 |
"locatefile=s" => \$opt_locate_file,
|
| 245 |
dpurdie |
119 |
"locatepkg=s" => \$opt_locate_package,
|
| 227 |
dpurdie |
120 |
"here" => \$opt_here,
|
|
|
121 |
"time" => \$opt_time,
|
|
|
122 |
"b|buildfile=s" => \&opts_buildfile,
|
| 245 |
dpurdie |
123 |
"java=s" => \$opt_java,
|
| 227 |
dpurdie |
124 |
"version=s", => \&opts_version,
|
|
|
125 |
"platform:s", => sub{ opts_extend( \$GBE_PLATFORM, @_ )},
|
|
|
126 |
"buildfilter:s" => sub{ opts_extend( \$GBE_BUILDFILTER, @_ )},
|
|
|
127 |
"abt:s" => sub{ opts_extend( \$GBE_ABT, @_ )},
|
| 277 |
dpurdie |
128 |
"exportvars!" => \$opt_export_vars,
|
| 227 |
dpurdie |
129 |
);
|
|
|
130 |
|
|
|
131 |
#
|
|
|
132 |
# Configure the error reporting process now that we have the user options
|
|
|
133 |
#
|
|
|
134 |
ErrorConfig( 'name' => 'JATS',
|
|
|
135 |
'debug' => $GBE_DEBUG,
|
|
|
136 |
'verbose' => $GBE_VERBOSE );
|
|
|
137 |
#
|
|
|
138 |
# Post process some of the options
|
|
|
139 |
#
|
|
|
140 |
Error ("Options not parsed. Use -help for help") unless $result;
|
| 263 |
dpurdie |
141 |
Verbose3 ('ARGS', @ARGV);
|
| 227 |
dpurdie |
142 |
|
|
|
143 |
#
|
|
|
144 |
# Option Helper Routine
|
|
|
145 |
# Save alternate buildfile. Flag that it has been set
|
|
|
146 |
#
|
|
|
147 |
sub opts_buildfile
|
|
|
148 |
{
|
| 283 |
dpurdie |
149 |
my ($junk, $bf) = @_;
|
|
|
150 |
$BUILD_FILE = $bf;
|
| 227 |
dpurdie |
151 |
$BUILD_FILE_SET = 1;
|
|
|
152 |
Verbose ("Use alternate buildfile: $BUILD_FILE");
|
| 283 |
dpurdie |
153 |
return;
|
| 227 |
dpurdie |
154 |
}
|
|
|
155 |
|
|
|
156 |
#
|
|
|
157 |
# Options Helper Routine
|
|
|
158 |
# Collect a space/comma delimited list and replace/append to string
|
|
|
159 |
# Allows the string to be reset
|
|
|
160 |
# Use of a +" will append to existing value
|
|
|
161 |
#
|
|
|
162 |
# arg1 - Ref to string to store data
|
|
|
163 |
# arg2 - Option name
|
|
|
164 |
# arg3 - Option value
|
|
|
165 |
#
|
|
|
166 |
sub opts_extend
|
|
|
167 |
{
|
|
|
168 |
my( $ref, $name, $value) = @_;
|
|
|
169 |
if ( $value )
|
|
|
170 |
{
|
|
|
171 |
$value =~ s/,/ /g;
|
|
|
172 |
$value = ${$ref} . ' ' . $value
|
|
|
173 |
if ( $value =~ s/\+/ /g );
|
|
|
174 |
$value =~ s/^\s+//;
|
|
|
175 |
$value =~ s/\s+/ /;
|
|
|
176 |
}
|
|
|
177 |
${$ref} = $value;
|
| 283 |
dpurdie |
178 |
return;
|
| 227 |
dpurdie |
179 |
}
|
|
|
180 |
|
|
|
181 |
#
|
|
|
182 |
# Options Helper routine
|
|
|
183 |
# Collect --version=version, then stop processing of the command line
|
|
|
184 |
# This will simulate a '--'
|
|
|
185 |
#
|
|
|
186 |
sub opts_version
|
|
|
187 |
{
|
| 283 |
dpurdie |
188 |
my ($junk, $vn) = @_;
|
|
|
189 |
$GBE_JATS_VERSION = $vn;
|
|
|
190 |
die("!FINISH\n");
|
| 227 |
dpurdie |
191 |
}
|
|
|
192 |
|
|
|
193 |
################################################################################
|
|
|
194 |
#
|
|
|
195 |
# Ensure that essential environment variables are present and that they
|
|
|
196 |
# do not contain spaces.
|
|
|
197 |
#
|
|
|
198 |
ReportError('Set env-var GBE_PERL (typically "/usr/bin/perl")') unless ( $GBE_PERL );
|
| 229 |
dpurdie |
199 |
ReportError('Set env-var GBE_DPKG (typically "/devl/dpkg_archive")') unless ( $GBE_DPKG );
|
|
|
200 |
ReportError('Set env-var GBE_CORE (typically "/devl/dpkg_archive/PACKAGE_TAG/VERSION_TAG")') unless ( $GBE_CORE );
|
| 279 |
dpurdie |
201 |
ReportError('Hostname cannot be determined') unless ( $GBE_HOSTNAME );
|
| 227 |
dpurdie |
202 |
|
| 229 |
dpurdie |
203 |
################################################################################
|
|
|
204 |
#
|
|
|
205 |
# Warn if using a version of perl that is newer than expected
|
|
|
206 |
# The 'require' does a lower limit test
|
|
|
207 |
#
|
| 283 |
dpurdie |
208 |
if ( ! $GBE_JATS_SANE )
|
|
|
209 |
{
|
|
|
210 |
Warning ("Perl Version may not be compatible",
|
|
|
211 |
"Jats has been tested with: 5.8.8",
|
|
|
212 |
"This version is: $]",
|
|
|
213 |
) if ( $] > 5.010000 );
|
| 227 |
dpurdie |
214 |
|
| 283 |
dpurdie |
215 |
Warning ("The PDK, as used by some deployed packages does not work with this version of perl.",
|
|
|
216 |
"ERG only has a licence for PDK V5 and this only works with Perl 5.6 and 5.8",
|
|
|
217 |
"This version is: $]",
|
|
|
218 |
) if ( $] > 5.009000 );
|
|
|
219 |
}
|
| 229 |
dpurdie |
220 |
|
|
|
221 |
#
|
|
|
222 |
# Warn if this is not an active state release
|
|
|
223 |
#
|
|
|
224 |
# Would be nice, but I can't figure out how to do it - yet
|
|
|
225 |
# The following does not work on all platforms
|
|
|
226 |
#
|
|
|
227 |
#unless ( $ActivePerl::VERSION )
|
|
|
228 |
#{
|
|
|
229 |
# Warning ("Perl does not appear to be an ActiveState Release", "Jats may not function as expected");
|
|
|
230 |
#}
|
|
|
231 |
#else
|
|
|
232 |
#{
|
|
|
233 |
# Verbose ("ActiveState Version: $ActivePerl::VERSION");
|
|
|
234 |
#}
|
|
|
235 |
|
| 227 |
dpurdie |
236 |
################################################################################
|
| 229 |
dpurdie |
237 |
#
|
| 245 |
dpurdie |
238 |
# Warn if this version of JATS is not correctly versioned
|
| 229 |
dpurdie |
239 |
# Users should be using correctly versioned copies of JATS. These come
|
|
|
240 |
# from dpkg_archive.
|
|
|
241 |
#
|
| 231 |
dpurdie |
242 |
Warning ("*** Unofficial version of JATS ***")
|
| 243 |
dpurdie |
243 |
if ( ! $GBE_JATS_SANE && $GBE_NOT_RELEASED );
|
| 229 |
dpurdie |
244 |
|
|
|
245 |
################################################################################
|
| 227 |
dpurdie |
246 |
# If running with cygwin then warn if the CYGWIN environment variable
|
|
|
247 |
# contains "tty". tty mode causes some strange behaviour such as:
|
|
|
248 |
# 1) Non flushing of perl scripts under some conditions (eg:create_dpkg)
|
|
|
249 |
#
|
|
|
250 |
if ( $ENV{'CYGWIN'} && $ENV{'CYGWIN'} =~ m/tty/ )
|
|
|
251 |
{
|
|
|
252 |
Warning ("The CYGWIN variable contains \"tty\".",
|
|
|
253 |
"This can cause strange behaviour with interactive scripts");
|
|
|
254 |
}
|
|
|
255 |
|
|
|
256 |
#
|
|
|
257 |
# Remove CDPATH - this breaks things when cygwin is running
|
|
|
258 |
# even if we are not running under cygwin perl
|
|
|
259 |
#
|
|
|
260 |
delete $ENV{'CDPATH'};
|
|
|
261 |
|
|
|
262 |
|
|
|
263 |
################################################################################
|
|
|
264 |
# Sanitize GBE_CORE and others for internal Perl use
|
|
|
265 |
# It may contain \ to be added to PATH but within perl is needs /
|
|
|
266 |
#
|
|
|
267 |
$PERL5LIB =~ tr~\\/~/~s;
|
|
|
268 |
|
|
|
269 |
TestDirectoryConfig( 'GBE_CORE' );
|
|
|
270 |
TestDirectoryConfig( 'GBE_BIN' );
|
|
|
271 |
TestDirectoryConfig( 'GBE_PERL' );
|
|
|
272 |
TestDirectoryConfig( 'GBE_DPLY' );
|
|
|
273 |
TestDirectoryConfig( 'GBE_DPKG' );
|
|
|
274 |
TestDirectoryConfig( 'GBE_DPKG_CACHE' );
|
|
|
275 |
TestDirectoryConfig( 'GBE_DPKG_LOCAL' );
|
|
|
276 |
TestDirectoryConfig( 'GBE_DPKG_STORE' );
|
|
|
277 |
TestDirectoryConfig( 'GBE_DPKG_SBOX' );
|
|
|
278 |
TestDirectoryConfig( 'GBE_SANDBOX' );
|
|
|
279 |
|
|
|
280 |
################################################################################
|
|
|
281 |
# Setup the Machine Type
|
|
|
282 |
#
|
|
|
283 |
# GBE_MACHTYPE is used to determine the BIN directory from which JATS will
|
|
|
284 |
# pull local binary executables from. The directory must exist.
|
|
|
285 |
#
|
|
|
286 |
# We need GBE_MACHTYPE to be correctly defined by the user
|
|
|
287 |
# This is machine specific and should be done in jats.sh/jats.bat
|
|
|
288 |
#
|
|
|
289 |
unless ( $GBE_MACHTYPE )
|
|
|
290 |
{
|
|
|
291 |
$GBE_MACHTYPE = 'win32' if ( $^O eq "cygwin" );
|
|
|
292 |
$GBE_MACHTYPE = 'win32' if ( $^O eq "MSWin32" );
|
|
|
293 |
$GBE_MACHTYPE = 'win32' if ( $^O eq "win95" );
|
|
|
294 |
Verbose ("Setting GBE_MACHTYPE: $GBE_MACHTYPE") ;
|
|
|
295 |
}
|
|
|
296 |
|
|
|
297 |
ReportError ('Set env-var GBE_MACHTYPE (typically "win32")') unless ( $GBE_MACHTYPE );
|
|
|
298 |
ErrorDoExit();
|
|
|
299 |
|
|
|
300 |
if ( $GBE_MACHTYPE eq 'win32' )
|
|
|
301 |
{
|
|
|
302 |
$PSPLIT = ';';
|
|
|
303 |
$GBE_UNIX = 0;
|
|
|
304 |
}
|
|
|
305 |
|
|
|
306 |
################################################################################
|
|
|
307 |
# Windows: If the user is running JATS from within the development view
|
|
|
308 |
# then they may not provide a drive letter in the full name of GBE_CORE
|
|
|
309 |
# For correct operation GBE_CORE needs to be able to run programs and
|
|
|
310 |
# scripts from any other drive
|
|
|
311 |
#
|
|
|
312 |
# If GBE_CORE does not have a driver letter - then add one
|
|
|
313 |
# Note: Use the CWD before any CD operations
|
|
|
314 |
#
|
|
|
315 |
if ( $GBE_MACHTYPE eq 'win32' && $GBE_CORE !~ m/^\w\:/ )
|
|
|
316 |
{
|
|
|
317 |
my $cwd = getcwd();
|
|
|
318 |
$GBE_CORE = substr( $cwd, 0, 2 ) . '/' . $GBE_CORE;
|
|
|
319 |
$GBE_CORE =~ s~//~/~g;
|
|
|
320 |
Verbose2 ("Setting GBE_CORE drive: $GBE_CORE");
|
|
|
321 |
}
|
|
|
322 |
|
|
|
323 |
################################################################################
|
|
|
324 |
# Attempt to run JATS from a local cache
|
|
|
325 |
# This mechanism allows JATS to be a link to a desired version on a network
|
|
|
326 |
# drive, but to have the version transferred locally if required
|
|
|
327 |
#
|
| 229 |
dpurdie |
328 |
# The transfer/check is only done on the first invocation of jats. If jats uses
|
| 245 |
dpurdie |
329 |
# jats to perform functions, then it will not be performed.
|
| 229 |
dpurdie |
330 |
#
|
| 245 |
dpurdie |
331 |
# If we want to run an alternate version of JATS, then don't attempt to
|
| 229 |
dpurdie |
332 |
# cache the initial version of JATS.
|
|
|
333 |
#
|
| 227 |
dpurdie |
334 |
if ( $ENV{GBE_CACHE_JATS} && ! $GBE_JATS_SANE && ! $GBE_JATS_VERSION)
|
|
|
335 |
{
|
|
|
336 |
my $state = "Not Cached: Not running from dpkg_archive";
|
|
|
337 |
#
|
|
|
338 |
# Must have the DPKG_ARCHIVE cache
|
| 229 |
dpurdie |
339 |
# Must be running from DPKG_ARCHIVE - prevent messing with local copies
|
| 227 |
dpurdie |
340 |
#
|
|
|
341 |
if ( $GBE_DPKG_CACHE )
|
|
|
342 |
{
|
| 229 |
dpurdie |
343 |
#
|
|
|
344 |
# JATS must be running from an archive, otherwise we assume that its
|
|
|
345 |
# a local copy. Detected by:
|
|
|
346 |
# GBE_NOT_RELEASED being set
|
|
|
347 |
# Lack of descpkg file
|
|
|
348 |
#
|
|
|
349 |
if ( ! $GBE_NOT_RELEASED && -f "$GBE_CORE/descpkg" )
|
| 227 |
dpurdie |
350 |
{
|
| 229 |
dpurdie |
351 |
my ($archive, $package) = LocateJatsVersion( $GBE_VERSION );
|
|
|
352 |
if ( $archive )
|
|
|
353 |
{
|
|
|
354 |
Verbose ("Update cached version of JATS: $GBE_VERSION");
|
|
|
355 |
#
|
|
|
356 |
# Attempt to cache the package
|
|
|
357 |
# Need enough JATS environment to run the cache_dpkg utility
|
|
|
358 |
#
|
| 283 |
dpurdie |
359 |
{
|
|
|
360 |
local %ENV = %ENV;
|
| 227 |
dpurdie |
361 |
|
| 283 |
dpurdie |
362 |
$ENV{GBE_TOOLS} = "$GBE_CORE/TOOLS";
|
|
|
363 |
$ENV{PERL5LIB} = "$GBE_CORE/TOOLS/LIB" ;
|
|
|
364 |
$ENV{GBE_BIN} = "$GBE_CORE/BIN.$GBE_MACHTYPE";
|
|
|
365 |
$ENV{GBE_VERBOSE} = $GBE_VERBOSE;
|
| 227 |
dpurdie |
366 |
|
| 283 |
dpurdie |
367 |
etool ( 'cache_dpkg.pl', $package );
|
|
|
368 |
}
|
| 227 |
dpurdie |
369 |
|
| 229 |
dpurdie |
370 |
my $tgt = "$GBE_DPKG_CACHE/$package";
|
|
|
371 |
if ( -d $tgt )
|
|
|
372 |
{
|
|
|
373 |
Verbose ("Using cached version of JATS: $GBE_VERSION");
|
|
|
374 |
$GBE_CORE = $tgt;
|
|
|
375 |
$state = "Cached";
|
|
|
376 |
}
|
|
|
377 |
else
|
|
|
378 |
{
|
|
|
379 |
$state = "Not Cached: Copy Failure";
|
|
|
380 |
}
|
| 227 |
dpurdie |
381 |
}
|
|
|
382 |
else
|
|
|
383 |
{
|
| 229 |
dpurdie |
384 |
$state = "Not Cached: Not found in archives";
|
| 227 |
dpurdie |
385 |
}
|
|
|
386 |
}
|
|
|
387 |
}
|
|
|
388 |
else
|
|
|
389 |
{
|
|
|
390 |
$state = "Not Cached: No GBE_DPKG_CACHE";
|
|
|
391 |
}
|
|
|
392 |
|
|
|
393 |
#
|
|
|
394 |
# Flag JATS having been cached on the machine
|
|
|
395 |
#
|
|
|
396 |
$ENV{GBE_CACHE_JATS} = $state;
|
|
|
397 |
}
|
|
|
398 |
|
|
|
399 |
|
|
|
400 |
################################################################################
|
|
|
401 |
# Establish a relationship between GBE_BIN, GBE_TOOLS and GBE_CONFIG
|
|
|
402 |
# unless the user has already provided one.
|
|
|
403 |
#
|
|
|
404 |
# Only NEED GBE_CORE - the others will be derived
|
|
|
405 |
#
|
|
|
406 |
unless ( $GBE_BIN )
|
|
|
407 |
{
|
|
|
408 |
$GBE_BIN = "$GBE_CORE/BIN.$GBE_MACHTYPE";
|
|
|
409 |
Verbose2 ("Setting GBE_BIN: $GBE_BIN");
|
|
|
410 |
}
|
|
|
411 |
ReportError ('GBE_MACHTYPE is not valid.',
|
|
|
412 |
'There must be a corresponding BIN directory in GBE_CORE',
|
|
|
413 |
"GBE_BIN : $GBE_BIN",
|
|
|
414 |
"GBE_MACHTYPE: $GBE_MACHTYPE"
|
|
|
415 |
) unless ( -d $GBE_BIN );
|
|
|
416 |
|
|
|
417 |
ReportError ('Machine specific binary directory does not appear to setup',
|
|
|
418 |
'After JATS is installed the PostInstall script must be run',
|
|
|
419 |
"GBE_BIN : $GBE_BIN"
|
|
|
420 |
) unless ( -x $GBE_BIN . '/sh' || -x $GBE_BIN . '/sh.exe' );
|
|
|
421 |
|
|
|
422 |
unless ( $GBE_TOOLS )
|
|
|
423 |
{
|
|
|
424 |
$GBE_TOOLS = "$GBE_CORE/TOOLS";
|
|
|
425 |
Verbose2 ("Setting GBE_TOOLS: $GBE_TOOLS");
|
|
|
426 |
}
|
|
|
427 |
|
|
|
428 |
unless ( $GBE_CONFIG )
|
|
|
429 |
{
|
|
|
430 |
$GBE_CONFIG = "$GBE_CORE/CFG";
|
|
|
431 |
Verbose2 ("Setting GBE_CONFIG: $GBE_CONFIG");
|
|
|
432 |
}
|
|
|
433 |
|
|
|
434 |
#
|
|
|
435 |
# Extend the PERL5 with our own Module Repository
|
|
|
436 |
#
|
|
|
437 |
$PERL5LIB = join( $PSPLIT, split( $PSPLIT, $PERL5LIB), "$GBE_CORE/TOOLS/LIB" );
|
|
|
438 |
|
|
|
439 |
|
|
|
440 |
################################################################################
|
|
|
441 |
# Sanity Test
|
|
|
442 |
# The ABT environment requires several parameters to specify the location
|
|
|
443 |
# of the Release/Deployment Managers
|
|
|
444 |
#
|
|
|
445 |
# GBE_DM_LOCATION will be set GBE_RM_LOCATION, if not set
|
|
|
446 |
#
|
|
|
447 |
# Only perform the test:
|
|
|
448 |
# - On the first invocation of JATS, not nested invocations
|
|
|
449 |
# - Based on the EnvVar, not the user option. This will allow a user
|
|
|
450 |
# to invoke ABT without the need for these values to be present
|
|
|
451 |
#
|
|
|
452 |
if ( ! $GBE_JATS_SANE && $ENV{GBE_RM_LOCATION} && ! $ENV{GBE_DM_LOCATION} )
|
|
|
453 |
{
|
|
|
454 |
$ENV{GBE_DM_LOCATION} = $ENV{GBE_RM_LOCATION};
|
|
|
455 |
}
|
|
|
456 |
|
|
|
457 |
if ( ! $GBE_JATS_SANE && $ENV{GBE_ABT} )
|
|
|
458 |
{
|
|
|
459 |
foreach my $var ( qw(GBE_DM_LOCATION GBE_DM_USERNAME GBE_DM_PASSWORD GBE_RM_URL))
|
|
|
460 |
{
|
|
|
461 |
Warning("Deployment Manager EnvVar may need to be defined: $var") unless ( $ENV{$var} );
|
|
|
462 |
}
|
|
|
463 |
|
|
|
464 |
foreach my $var ( qw(GBE_RM_LOCATION GBE_RM_USERNAME GBE_RM_PASSWORD GBE_DM_URL))
|
|
|
465 |
{
|
|
|
466 |
ReportError("Release Manager EnvVar needs to be defined: $var") unless ( $ENV{$var} );
|
|
|
467 |
}
|
|
|
468 |
}
|
|
|
469 |
|
|
|
470 |
################################################################################
|
|
|
471 |
#
|
|
|
472 |
# Change to the required root directory
|
|
|
473 |
# The user may specify a start directory( -c )
|
|
|
474 |
#
|
|
|
475 |
change_dir ( $opt_dir );
|
| 245 |
dpurdie |
476 |
|
|
|
477 |
|
|
|
478 |
################################################################################
|
|
|
479 |
# Locate the root of the build - if required
|
|
|
480 |
# This is used by the autobuild tools to:
|
|
|
481 |
# 1) Locate the build.pl file for JATS based builds
|
|
|
482 |
# The name of the target package can be provided to resolve
|
|
|
483 |
# cases of multiple build files.
|
|
|
484 |
#
|
|
|
485 |
# 2) Locate the <ProjectName>depends.xml file for ANT based builds
|
|
|
486 |
# The name of the buildfile will be specified
|
|
|
487 |
# There must be only one file of this name in the tree
|
|
|
488 |
#
|
|
|
489 |
# Note: If only one build file is found, then it will be used
|
|
|
490 |
# It will not be sanity tested. This is intentional
|
|
|
491 |
# for backward compatability.
|
|
|
492 |
#
|
|
|
493 |
if ( $opt_locate || $opt_locate_file || $opt_locate_package )
|
| 227 |
dpurdie |
494 |
{
|
| 245 |
dpurdie |
495 |
#
|
|
|
496 |
# Allow the user to specify the name of the build file
|
|
|
497 |
# This will be used in ANT builds as the name changes
|
|
|
498 |
# but it can be predetermined
|
|
|
499 |
#
|
| 227 |
dpurdie |
500 |
$opt_locate_file = $BUILD_FILE unless ( $opt_locate_file );
|
|
|
501 |
|
| 245 |
dpurdie |
502 |
#
|
|
|
503 |
# Create a Build File Scanner object
|
|
|
504 |
# This will be used to locate a suitable build file
|
|
|
505 |
#
|
| 227 |
dpurdie |
506 |
Verbose ("Autolocate the build file: $opt_locate_file");
|
|
|
507 |
|
| 245 |
dpurdie |
508 |
my $bscanner = BuildFileScanner ( '.', $opt_locate_file );
|
|
|
509 |
my $count = $bscanner->locate();
|
|
|
510 |
|
|
|
511 |
Error ("Autolocate. Build file not found: $opt_locate_file" )
|
|
|
512 |
if ( $count <= 0 );
|
|
|
513 |
|
| 227 |
dpurdie |
514 |
#
|
| 245 |
dpurdie |
515 |
# If multiple build files have been found
|
|
|
516 |
# If $opt_locate_package is set then we can attempt to resolve the package
|
| 227 |
dpurdie |
517 |
#
|
| 245 |
dpurdie |
518 |
# Scan the buildfiles and determine the names of the packages that will
|
|
|
519 |
# be built. This can be used to generate nice error messages
|
|
|
520 |
if ( $count > 1 )
|
|
|
521 |
{
|
|
|
522 |
$bscanner->scan();
|
|
|
523 |
$count = $bscanner->match( $opt_locate_package );
|
|
|
524 |
#DebugDumpData ("Bscan", \$bscanner );
|
| 227 |
dpurdie |
525 |
|
| 245 |
dpurdie |
526 |
my $errmess;
|
|
|
527 |
unless ( $opt_locate_package ) {
|
|
|
528 |
$errmess = "Use -locatepkg=pkg to resolve required package";
|
|
|
529 |
|
|
|
530 |
} elsif ( $count <= 0 ) {
|
|
|
531 |
$errmess = "None found that build package: $opt_locate_package";
|
|
|
532 |
|
|
|
533 |
} elsif ( $count > 1 ) {
|
|
|
534 |
$errmess = "Multiple build files build the required package: $opt_locate_package";
|
|
|
535 |
}
|
|
|
536 |
|
|
|
537 |
#
|
|
|
538 |
# Pretty error display
|
|
|
539 |
# Display build directory and the package name (mangled)
|
|
|
540 |
#
|
|
|
541 |
if ( $errmess )
|
|
|
542 |
{
|
|
|
543 |
Error ("Autolocate. Multiple build files found.",
|
|
|
544 |
$errmess,
|
|
|
545 |
"Build files found in:", $bscanner->formatData() );
|
|
|
546 |
}
|
|
|
547 |
}
|
|
|
548 |
|
| 227 |
dpurdie |
549 |
#
|
| 245 |
dpurdie |
550 |
# Extract the required build file directory
|
| 227 |
dpurdie |
551 |
#
|
| 245 |
dpurdie |
552 |
my $dir = $bscanner->getMatchDir() || '';
|
|
|
553 |
Verbose ("Autolocate. Found $count build files: $dir");
|
| 227 |
dpurdie |
554 |
|
|
|
555 |
#
|
|
|
556 |
# Select the one true build directory
|
|
|
557 |
#
|
| 245 |
dpurdie |
558 |
change_dir ( $dir );
|
| 227 |
dpurdie |
559 |
|
|
|
560 |
#
|
|
|
561 |
# Kill location scan as we have already located the build file
|
|
|
562 |
#
|
|
|
563 |
$opt_here = 1;
|
|
|
564 |
}
|
|
|
565 |
|
|
|
566 |
################################################################################
|
|
|
567 |
# Version redirection
|
|
|
568 |
# JATS allows the version of JATS to be used to be specified
|
|
|
569 |
# This mechanism operates on the assumption that the required version is
|
|
|
570 |
# present in dpkg_archive. If a specific version is required then the bulk
|
|
|
571 |
# of this script is bypassed and the arguments passed directly to the required
|
|
|
572 |
# target
|
|
|
573 |
#
|
|
|
574 |
if ( $GBE_JATS_VERSION && $GBE_JATS_VERSION eq $GBE_VERSION )
|
|
|
575 |
{
|
|
|
576 |
Message("Using current JATS version: $GBE_JATS_VERSION" );
|
|
|
577 |
$GBE_JATS_VERSION = undef;
|
|
|
578 |
}
|
|
|
579 |
|
|
|
580 |
if ( $GBE_JATS_VERSION )
|
|
|
581 |
{
|
|
|
582 |
#
|
|
|
583 |
# Report any errors detected
|
|
|
584 |
#
|
|
|
585 |
ErrorDoExit();
|
|
|
586 |
Message("Using JATS version: $GBE_JATS_VERSION");
|
|
|
587 |
|
|
|
588 |
#
|
| 245 |
dpurdie |
589 |
# If we have a cache available, then attempt to transfer the required
|
|
|
590 |
# version into the cache. If we don't have a cache, then don't even try.
|
| 229 |
dpurdie |
591 |
#
|
| 245 |
dpurdie |
592 |
if ( $GBE_DPKG_CACHE )
|
|
|
593 |
{
|
|
|
594 |
#
|
|
|
595 |
# Attempt to locate the desired version in one of the well known
|
|
|
596 |
# package archives. This will give us its package name.
|
|
|
597 |
#
|
|
|
598 |
my ($archive, $package) = LocateJatsVersion ($GBE_JATS_VERSION);
|
|
|
599 |
Error("Cannot find JATS version: $GBE_JATS_VERSION") unless $archive;
|
| 229 |
dpurdie |
600 |
|
| 245 |
dpurdie |
601 |
#
|
|
|
602 |
# Do NOT propagate GBE_JATS_VERSION in the environment
|
|
|
603 |
# This will only cause problem in recursion
|
|
|
604 |
#
|
|
|
605 |
delete $ENV{GBE_JATS_VERSION};
|
| 227 |
dpurdie |
606 |
|
| 245 |
dpurdie |
607 |
#
|
|
|
608 |
# Attempt to cache the package
|
|
|
609 |
# Need enough JATS environment to run the utility
|
|
|
610 |
#
|
| 283 |
dpurdie |
611 |
{
|
|
|
612 |
local %ENV = %ENV;
|
| 227 |
dpurdie |
613 |
|
| 283 |
dpurdie |
614 |
$ENV{PERL5LIB} = $PERL5LIB;
|
|
|
615 |
$ENV{GBE_BIN} = $GBE_BIN;
|
|
|
616 |
$ENV{GBE_VERBOSE} = $GBE_VERBOSE;
|
|
|
617 |
$ENV{GBE_TOOLS} = $GBE_TOOLS;
|
| 227 |
dpurdie |
618 |
|
| 283 |
dpurdie |
619 |
etool ( 'cache_dpkg.pl', $package );
|
|
|
620 |
}
|
| 245 |
dpurdie |
621 |
}
|
| 227 |
dpurdie |
622 |
|
|
|
623 |
#
|
| 229 |
dpurdie |
624 |
# Locate the version of JATS to be run (again)
|
| 227 |
dpurdie |
625 |
# It should be in the cache, but it may not be
|
|
|
626 |
#
|
| 245 |
dpurdie |
627 |
my ($archive, $package) = LocateJatsVersion ($GBE_JATS_VERSION);
|
| 229 |
dpurdie |
628 |
Error("Cannot find JATS version: $GBE_JATS_VERSION") unless $archive;
|
|
|
629 |
|
|
|
630 |
$GBE_CORE = "$archive/$package";
|
| 227 |
dpurdie |
631 |
Verbose2 ("Using alternate version: $GBE_CORE");
|
|
|
632 |
|
|
|
633 |
#
|
|
|
634 |
# Run the specified version of JATS
|
|
|
635 |
# Force the required version of GBE_CORE and invoke the wrapper script
|
|
|
636 |
#
|
|
|
637 |
$ENV{GBE_CORE} = $GBE_CORE;
|
|
|
638 |
|
|
|
639 |
Verbose("Use ARGV: @ARGV");
|
|
|
640 |
$RESULT = System ($GBE_PERL, "$GBE_CORE/TOOLS/jats.pl", @ARGV );
|
|
|
641 |
do_exit();
|
|
|
642 |
}
|
|
|
643 |
|
|
|
644 |
################################################################################
|
|
|
645 |
# Determine the current directory
|
|
|
646 |
# Note: Don't use `pwd`. This sucks for so many reasons including
|
|
|
647 |
# the fact that it may not be available until this wrapper
|
|
|
648 |
# script has done it job.
|
|
|
649 |
#
|
|
|
650 |
$CWD = getcwd();
|
|
|
651 |
Verbose ("Current Working Directory: $CWD");
|
|
|
652 |
Warning ("Current working directory contains spaces") if ( $CWD =~ m/\s/ );
|
|
|
653 |
|
|
|
654 |
|
|
|
655 |
################################################################################
|
|
|
656 |
# Setup drive
|
|
|
657 |
# This is only required under windows
|
|
|
658 |
# Purpose is unclear, but under windows it is required, so lets create one
|
|
|
659 |
# if its not present
|
|
|
660 |
#
|
|
|
661 |
unless ( $GBE_UNIX )
|
|
|
662 |
{
|
|
|
663 |
unless ( $GBE_DRV )
|
|
|
664 |
{
|
|
|
665 |
($GBE_DRV = $CWD ) =~ s~[^:]*$~~;
|
|
|
666 |
$GBE_DRV = "c:" if ( $GBE_DRV !~ m/:/ );
|
|
|
667 |
Verbose2( "Setting GBE_DRV: $GBE_DRV" );
|
|
|
668 |
}
|
|
|
669 |
}
|
|
|
670 |
|
|
|
671 |
################################################################################
|
|
|
672 |
# Sanity test the main archive variable
|
|
|
673 |
# This MUST address one archive
|
|
|
674 |
#
|
|
|
675 |
|
|
|
676 |
Error ("GBE_DPKG must not be a path list: $GBE_DPKG")
|
|
|
677 |
if ( $GBE_DPKG =~ /$PSPLIT/ );
|
|
|
678 |
Error ("GBE_DPKG is not a directory : $GBE_DPKG")
|
|
|
679 |
unless( -d $GBE_DPKG );
|
|
|
680 |
|
|
|
681 |
################################################################################
|
|
|
682 |
# Sanity test the cache
|
|
|
683 |
#
|
|
|
684 |
Error ("GBE_DPKG_CACHE is not a directory : $GBE_DPKG_CACHE")
|
|
|
685 |
if ( $GBE_DPKG_CACHE && ! -d $GBE_DPKG_CACHE );
|
|
|
686 |
|
|
|
687 |
################################################################################
|
|
|
688 |
# Sanity test the global store
|
|
|
689 |
#
|
|
|
690 |
Error ("GBE_DPKG_STORE is not a directory : $GBE_DPKG_STORE")
|
|
|
691 |
if ( $GBE_DPKG_STORE && ! -d $GBE_DPKG_STORE );
|
|
|
692 |
|
|
|
693 |
Error ("GBE_DPLY is not a directory : $GBE_DPLY")
|
|
|
694 |
if ( $GBE_DPLY && ! -d $GBE_DPLY );
|
|
|
695 |
|
|
|
696 |
########################################################################
|
|
|
697 |
#
|
|
|
698 |
# Locate a local_dpkg_archive directory, by searching from the CWD
|
|
|
699 |
# to the root of the file system
|
|
|
700 |
#
|
|
|
701 |
unless ( $GBE_DPKG_LOCAL )
|
|
|
702 |
{
|
| 283 |
dpurdie |
703 |
($GBE_DPKG_LOCAL) = scan_for_dir ('local_dpkg_archive');
|
| 227 |
dpurdie |
704 |
}
|
|
|
705 |
else
|
|
|
706 |
{
|
|
|
707 |
Error ("GBE_DPKG_LOCAL is not a directory : $GBE_DPKG_LOCAL")
|
|
|
708 |
unless( -d $GBE_DPKG_LOCAL );
|
|
|
709 |
}
|
|
|
710 |
|
|
|
711 |
########################################################################
|
|
|
712 |
#
|
|
|
713 |
# Locate a sandbox_dpkg_archive directory by searching from the CWD
|
|
|
714 |
# to the root of the file system
|
|
|
715 |
#
|
| 241 |
dpurdie |
716 |
# sandbox_dpkg_archive is a dpkg_archive for packages that are being
|
|
|
717 |
# co-developed. Package Versions within the sandbox are ignored
|
| 227 |
dpurdie |
718 |
#
|
| 241 |
dpurdie |
719 |
|
|
|
720 |
#
|
|
|
721 |
# Ensure that the user does not set $GBE_SANDBOX or $GBE_DPKG_SBOX
|
|
|
722 |
# $GBE_JATS_SANE will be set for multiple invocations, thus it is cleared
|
|
|
723 |
# for the first one (unless the user messes with it).
|
|
|
724 |
#
|
|
|
725 |
unless ( $GBE_JATS_SANE )
|
| 227 |
dpurdie |
726 |
{
|
| 241 |
dpurdie |
727 |
Error ("GBE_SANDBOX must not be set by the user") if ( $GBE_SANDBOX );
|
|
|
728 |
Error ("GBE_DPKG_SBOX must not be set by the user") if ( $GBE_DPKG_SBOX );
|
|
|
729 |
|
|
|
730 |
#
|
|
|
731 |
# The ABT does not use the sandbox
|
|
|
732 |
# It will never be found and will be ignored
|
|
|
733 |
#
|
|
|
734 |
unless ( $GBE_ABT )
|
|
|
735 |
{
|
| 277 |
dpurdie |
736 |
($GBE_DPKG_SBOX,$GBE_SANDBOX) = scan_for_dir ('sandbox_dpkg_archive');
|
| 227 |
dpurdie |
737 |
}
|
|
|
738 |
}
|
|
|
739 |
|
|
|
740 |
########################################################################
|
|
|
741 |
#
|
|
|
742 |
# Ensure that the user has been set
|
|
|
743 |
# Under windows USER may not be set, but USERNAME may be
|
|
|
744 |
#
|
|
|
745 |
$USER = $ENV{ 'USERNAME' } || '' unless ( $USER );
|
|
|
746 |
$USER = $ENV{ 'LOGNAME' } || '' unless ( $USER );
|
|
|
747 |
|
|
|
748 |
################################################################################
|
|
|
749 |
# Sanitize the PATH variable
|
|
|
750 |
# Some of the Win32 binary tools used by JATS cannot handle lower case Path
|
|
|
751 |
# Force an upper case PATH
|
|
|
752 |
#
|
|
|
753 |
my $PATH = '';
|
|
|
754 |
$PATH .= delete( $ENV{ 'Path' } ) if (exists $ENV{ 'Path' });
|
|
|
755 |
$PATH .= delete( $ENV{ 'path' } ) if (exists $ENV{ 'path' });
|
|
|
756 |
$PATH .= delete( $ENV{ 'PATH' } ) if (exists $ENV{ 'PATH' });
|
| 277 |
dpurdie |
757 |
$ENV{'PATH'} = $PATH;
|
| 227 |
dpurdie |
758 |
|
|
|
759 |
#
|
|
|
760 |
# Windows now defines ComSpec. This is only a problem when programs are
|
|
|
761 |
# started up without the use of cmd.exe - like the JATS internal sh.exe
|
|
|
762 |
# Correct by deleting the environment variable and forcing it to be uppercase
|
|
|
763 |
#
|
|
|
764 |
my $COMSPEC = '';
|
|
|
765 |
$COMSPEC = delete( $ENV{'COMSPEC'} ) if ( exists $ENV{'COMSPEC'} );
|
|
|
766 |
|
|
|
767 |
################################################################################
|
|
|
768 |
# There is some really ugly interaction between Cygwin, ActiveState Perl 5.8.2
|
|
|
769 |
# and xmake. Even if none of the cygwin bits are used within JATS the fact that
|
|
|
770 |
# Cygwin is in the path causes problems.
|
|
|
771 |
#
|
|
|
772 |
# Problems seen:
|
|
|
773 |
# 1) "jats build" xmake fails with a segment fault. Possibly when
|
|
|
774 |
# displaying an error message
|
|
|
775 |
# 2) Warnings and messages generated from within Perl don't always appear
|
|
|
776 |
# In particular. The output from a Message() within a PLATFORM/xxx file
|
|
|
777 |
# does not get displayed.
|
|
|
778 |
#
|
|
|
779 |
# Solution:
|
|
|
780 |
# Remove cygwin from the PATH
|
|
|
781 |
#
|
|
|
782 |
$PATH =~ s~c:\\cygwin[^;]*;~~ig;
|
|
|
783 |
|
|
|
784 |
################################################################################
|
|
|
785 |
# Ensure that the PATH contains the PERL executable
|
|
|
786 |
# Need to true path to the PERL executable so that the user has access to some
|
|
|
787 |
# of the perl utility programs such as pod2html
|
|
|
788 |
#
|
|
|
789 |
$PATH = $Config{binexp} . $PSPLIT . $PATH;
|
|
|
790 |
|
|
|
791 |
################################################################################
|
|
|
792 |
# There is more ugliness if GBE_BIN is not in the users path
|
|
|
793 |
# I suspect that it something within xmake (under win32) and that it needs
|
|
|
794 |
# to be able to find sh within the path - even though its fully pathed
|
|
|
795 |
#
|
|
|
796 |
# Add GBE_BIN to the start of the path to assist in searching
|
|
|
797 |
# Also ensure that we pickup our version of utilities instead of random
|
|
|
798 |
# versions.
|
|
|
799 |
#
|
|
|
800 |
my $GBE_BIN_ADD = $GBE_BIN;
|
|
|
801 |
$GBE_BIN_ADD =~ s~/~\\~g unless ( $GBE_UNIX );
|
|
|
802 |
$PATH = $GBE_BIN_ADD . $PSPLIT . $PATH;
|
|
|
803 |
|
|
|
804 |
################################################################################
|
|
|
805 |
# Clean PATH
|
|
|
806 |
# Remove duplicates
|
|
|
807 |
# Remove empty elements
|
|
|
808 |
# Clean path endings
|
| 245 |
dpurdie |
809 |
# Place non-existent paths at the end. They will be seen, but not scanned
|
| 227 |
dpurdie |
810 |
#
|
|
|
811 |
{
|
|
|
812 |
my @new_path;
|
|
|
813 |
my @non_exist;
|
|
|
814 |
my %seen;
|
|
|
815 |
foreach ( split $PSPLIT, $PATH )
|
|
|
816 |
{
|
|
|
817 |
s~[/\\]+$~~; # Remove trailing / or \
|
|
|
818 |
my $name = ( $GBE_UNIX ) ? $_ : lc ($_); # Windows is case insensitive
|
|
|
819 |
next unless ( $_ ); # Remove empty elements
|
|
|
820 |
next if ( /^\.+$/ ); # Remove . and ..
|
|
|
821 |
next if ( exists $seen{$name} ); # Remove duplicates
|
|
|
822 |
if ( -d $_ ) {
|
|
|
823 |
push @new_path, $_; # Exists
|
|
|
824 |
} else {
|
| 245 |
dpurdie |
825 |
push @non_exist, $_; # Place non existent paths at the end
|
| 227 |
dpurdie |
826 |
}
|
|
|
827 |
$seen{$name} = 1;
|
|
|
828 |
}
|
|
|
829 |
$PATH = join( $PSPLIT, @new_path, @non_exist );
|
|
|
830 |
}
|
|
|
831 |
|
|
|
832 |
################################################################################
|
|
|
833 |
# Windows: Ensure that cmd.exe is in the users PATH
|
|
|
834 |
# If cmd.exe cannot be found then the 'system' command will not work
|
|
|
835 |
#
|
|
|
836 |
unless ( $GBE_UNIX )
|
|
|
837 |
{
|
|
|
838 |
my $cmd_found;
|
|
|
839 |
foreach ( split $PSPLIT, $PATH )
|
|
|
840 |
{
|
|
|
841 |
my $file = $_ . "/cmd.exe";
|
|
|
842 |
Verbose2 ("Look for: $file");
|
|
|
843 |
if ( -x $file )
|
|
|
844 |
{
|
|
|
845 |
$cmd_found = 1;
|
|
|
846 |
Verbose ("Found: $file");
|
|
|
847 |
last;
|
|
|
848 |
}
|
|
|
849 |
}
|
|
|
850 |
|
|
|
851 |
Warning( "Users PATH does not contain \"cmd.exe\"",
|
|
|
852 |
"System commands may not work" ) unless $cmd_found;
|
|
|
853 |
}
|
|
|
854 |
|
|
|
855 |
################################################################################
|
|
|
856 |
# Sanitize the Microsoft Visual Studio environment variables LIB and INCLUDE.
|
|
|
857 |
# If these have a trailing \ then the generated makefiles
|
|
|
858 |
# will fail. This is impossible to detect and fix within make so do it here
|
|
|
859 |
#
|
|
|
860 |
# Note: JATS no longer allows these environment variables through to the
|
|
|
861 |
# makefiles.
|
|
|
862 |
#
|
|
|
863 |
unless ( $GBE_UNIX )
|
|
|
864 |
{
|
|
|
865 |
for my $var qw ( LIB INCLUDE )
|
|
|
866 |
{
|
|
|
867 |
my $evar = $ENV{$var};
|
|
|
868 |
if ( $evar )
|
|
|
869 |
{
|
|
|
870 |
$evar =~ s~\\;~;~g; # Remove trailing \ from components \; -> ;
|
|
|
871 |
$evar =~ s~\\$~~; # Remove trailing \
|
|
|
872 |
$evar =~ s~;$~~; # Remove trailing ;
|
|
|
873 |
$evar =~ s~;;~;~g; # Remove empty items ;;
|
|
|
874 |
$ENV{$var} = $evar;
|
|
|
875 |
}
|
|
|
876 |
}
|
|
|
877 |
}
|
|
|
878 |
|
|
|
879 |
################################################################################
|
|
|
880 |
# Setup the default JAVA_HOME
|
|
|
881 |
# User should specify 1.4, 1.5,1.6 ....
|
|
|
882 |
#
|
|
|
883 |
$JAVA_HOME = get_java_home ($opt_java)
|
|
|
884 |
if ( $opt_java );
|
|
|
885 |
|
|
|
886 |
|
|
|
887 |
################################################################################
|
| 277 |
dpurdie |
888 |
# Update the environment variables used by JATS, unless requested otherise.
|
| 227 |
dpurdie |
889 |
#
|
| 277 |
dpurdie |
890 |
# If JATS is being used to startup build daemons, then we don't want to
|
|
|
891 |
# export many of the calculated values into the environment. In particular
|
|
|
892 |
# GBE_CORE, GBE_BIN, GBE_CONFIG and GBE_TOOLS must not be exported as it will
|
|
|
893 |
# prevent the daemon from picking up the 'current' version of JATS
|
|
|
894 |
#
|
|
|
895 |
#
|
| 287 |
dpurdie |
896 |
|
| 277 |
dpurdie |
897 |
if ( $opt_export_vars )
|
|
|
898 |
{
|
|
|
899 |
$ENV{'PATH'} = $PATH;
|
|
|
900 |
$ENV{'GBE_VERSION'} = $GBE_VERSION;
|
|
|
901 |
$ENV{'GBE_CORE'} = $GBE_CORE;
|
|
|
902 |
$ENV{'GBE_BIN'} = $GBE_BIN;
|
|
|
903 |
$ENV{'GBE_CONFIG'} = $GBE_CONFIG;
|
|
|
904 |
$ENV{'GBE_DPLY'} = $GBE_DPLY;
|
|
|
905 |
$ENV{'GBE_DPKG'} = $GBE_DPKG;
|
|
|
906 |
$ENV{'JATS_HOME'} = $GBE_DPKG;
|
|
|
907 |
$ENV{'GBE_DPKG_CACHE'} = $GBE_DPKG_CACHE;
|
|
|
908 |
$ENV{'GBE_DPKG_STORE'} = $GBE_DPKG_STORE;
|
|
|
909 |
$ENV{'GBE_DPKG_LOCAL'} = $GBE_DPKG_LOCAL;
|
|
|
910 |
$ENV{'GBE_SANDBOX'} = $GBE_SANDBOX;
|
|
|
911 |
$ENV{'GBE_DPKG_SBOX'} = $GBE_DPKG_SBOX;
|
|
|
912 |
$ENV{'GBE_PERL'} = $GBE_PERL;
|
|
|
913 |
$ENV{'GBE_TOOLS'} = $GBE_TOOLS;
|
|
|
914 |
$ENV{'GBE_MACHTYPE'} = $GBE_MACHTYPE;
|
|
|
915 |
$ENV{'GBE_HOSTMACH'} = $GBE_HOSTMACH;
|
|
|
916 |
$ENV{'GBE_PLATFORM'} = $GBE_PLATFORM;
|
|
|
917 |
$ENV{'GBE_DRV'} = $GBE_DRV;
|
|
|
918 |
$ENV{'PERL5LIB'} = $PERL5LIB;
|
|
|
919 |
$ENV{'JAVA_HOME'} = $JAVA_HOME if ($JAVA_HOME);
|
|
|
920 |
$ENV{'GBE_JATS_SANE'} = 1;
|
|
|
921 |
}
|
| 287 |
dpurdie |
922 |
else
|
|
|
923 |
{
|
|
|
924 |
#
|
|
|
925 |
# Delete, from the environment, values that are related to selecting
|
|
|
926 |
# the version of JATS being used
|
|
|
927 |
#
|
|
|
928 |
foreach ( qw( GBE_VERSION GBE_CORE GBE_BIN GBE_CONFIG GBE_TOOLS GBE_DRV PERL5LIB GBE_DPKG_SBOX GBE_SANDBOX GBE_PLATFORM GBE_JATS_SANE ) )
|
|
|
929 |
{
|
|
|
930 |
delete $ENV{$_};
|
|
|
931 |
}
|
|
|
932 |
}
|
| 277 |
dpurdie |
933 |
|
|
|
934 |
#
|
|
|
935 |
# The following don't affect the operation of the build daemons selecting
|
|
|
936 |
# the current version of JATS. Some need to be passed through anyway
|
|
|
937 |
#
|
| 227 |
dpurdie |
938 |
$ENV{'GBE_BUILDFILTER'} = $GBE_BUILDFILTER;
|
| 277 |
dpurdie |
939 |
$ENV{'GBE_ABT'} = $GBE_ABT if ($GBE_ABT);
|
| 227 |
dpurdie |
940 |
$ENV{'GBE_DEBUG'} = $GBE_DEBUG;
|
|
|
941 |
$ENV{'GBE_VERBOSE'} = $GBE_VERBOSE;
|
|
|
942 |
$ENV{'GBE_UNIX'} = $GBE_UNIX;
|
|
|
943 |
$ENV{'USER'} = $USER;
|
| 277 |
dpurdie |
944 |
$ENV{'COMSPEC'} = $COMSPEC;
|
| 279 |
dpurdie |
945 |
$ENV{'GBE_HOSTNAME'} = $GBE_HOSTNAME;
|
| 227 |
dpurdie |
946 |
|
|
|
947 |
#-------------------------------------------------------------------------------
|
| 229 |
dpurdie |
948 |
# Function : LocateJatsVersion
|
|
|
949 |
#
|
| 245 |
dpurdie |
950 |
# Description : Scan archives looking for a specified version of JATS
|
| 229 |
dpurdie |
951 |
# Complicated by the name change from core_devl to jats
|
| 245 |
dpurdie |
952 |
# that occurred circa version 2.71.7.
|
| 229 |
dpurdie |
953 |
# The required version may be in either of the packages
|
|
|
954 |
#
|
|
|
955 |
# Inputs : $version - Version to locate
|
|
|
956 |
#
|
|
|
957 |
# Returns : undef - if not found
|
|
|
958 |
# Array of:
|
|
|
959 |
# Repository
|
|
|
960 |
# package/version
|
|
|
961 |
#
|
|
|
962 |
sub LocateJatsVersion
|
|
|
963 |
{
|
|
|
964 |
my ($version) = @_;
|
|
|
965 |
my $package;
|
|
|
966 |
my $path;
|
|
|
967 |
|
|
|
968 |
foreach my $archive qw ( GBE_DPKG_LOCAL GBE_DPKG_CACHE GBE_DPKG GBE_DPKG_STORE )
|
|
|
969 |
{
|
|
|
970 |
no strict 'refs';
|
|
|
971 |
$path = ${$archive};
|
|
|
972 |
use strict 'refs';
|
|
|
973 |
next unless ( $path );
|
|
|
974 |
|
|
|
975 |
foreach my $package qw( jats core_devl )
|
|
|
976 |
{
|
|
|
977 |
Verbose2( "ExamineDir: $path/$package/$version" );
|
|
|
978 |
if ( -d "$path/$package/$version" )
|
|
|
979 |
{
|
| 283 |
dpurdie |
980 |
return $path, "$package/$version";
|
| 229 |
dpurdie |
981 |
}
|
|
|
982 |
}
|
|
|
983 |
}
|
| 283 |
dpurdie |
984 |
return;
|
| 229 |
dpurdie |
985 |
}
|
|
|
986 |
|
|
|
987 |
|
|
|
988 |
#-------------------------------------------------------------------------------
|
| 227 |
dpurdie |
989 |
# Function : TestDirectoryConfig
|
|
|
990 |
#
|
|
|
991 |
# Description : Sanity test a user configurable directory or file
|
|
|
992 |
# Must not contain spaces
|
|
|
993 |
# Must not be a network drive ie: //computer
|
|
|
994 |
#
|
|
|
995 |
# Inputs :
|
|
|
996 |
#
|
|
|
997 |
# Returns :
|
|
|
998 |
#
|
|
|
999 |
sub TestDirectoryConfig
|
|
|
1000 |
{
|
|
|
1001 |
my ($dir) = @_;
|
|
|
1002 |
|
|
|
1003 |
no strict 'refs';
|
|
|
1004 |
my $val = ${$dir};
|
|
|
1005 |
|
|
|
1006 |
if ( $val )
|
|
|
1007 |
{
|
|
|
1008 |
#
|
|
|
1009 |
# Cleanup the path
|
|
|
1010 |
#
|
|
|
1011 |
$val =~ tr~\\/~/~s;
|
|
|
1012 |
$val =~ s~/+$~~;
|
| 255 |
dpurdie |
1013 |
$val = '' if ( $val eq '-' || $val eq 'none' );
|
| 227 |
dpurdie |
1014 |
${$dir} = $val;
|
|
|
1015 |
|
|
|
1016 |
ReportError("$dir path cannot contain spaces: $val") if ( $val =~ m/\s/ );
|
|
|
1017 |
ReportError("$dir path cannot be a computer name: $val") if ( $val =~ m~^//~ );
|
|
|
1018 |
}
|
|
|
1019 |
use strict 'refs';
|
| 283 |
dpurdie |
1020 |
return;
|
| 227 |
dpurdie |
1021 |
}
|
|
|
1022 |
|
|
|
1023 |
#-------------------------------------------------------------------------------
|
|
|
1024 |
# Function : change_dir
|
|
|
1025 |
#
|
|
|
1026 |
# Description : change directory to the specified directory
|
|
|
1027 |
#
|
|
|
1028 |
# Inputs : $1 - Target directory
|
|
|
1029 |
#
|
|
|
1030 |
# Returns :
|
|
|
1031 |
#
|
|
|
1032 |
sub change_dir
|
|
|
1033 |
{
|
|
|
1034 |
my ($dir) = @_;
|
|
|
1035 |
|
|
|
1036 |
if ( $dir && $dir !~ m/^\.$/ )
|
|
|
1037 |
{
|
|
|
1038 |
Verbose ("Changing to JATS build directory: $dir");
|
|
|
1039 |
chdir $dir || Error ("Bad change directory: $dir");
|
|
|
1040 |
}
|
|
|
1041 |
|
|
|
1042 |
#
|
|
|
1043 |
# Reset the CWD
|
|
|
1044 |
# Note: Don't use `pwd`. This sucks for so many reasons including
|
|
|
1045 |
# the fact that it may not be available until this wrapper
|
|
|
1046 |
# script has done it job.
|
|
|
1047 |
#
|
|
|
1048 |
$CWD = getcwd();
|
|
|
1049 |
$CWD =~tr~\\/~/~s;
|
|
|
1050 |
Warning ("Current working directory contains spaces") if ( $CWD =~ m/\s/ );
|
| 283 |
dpurdie |
1051 |
return;
|
| 227 |
dpurdie |
1052 |
}
|
|
|
1053 |
|
|
|
1054 |
#-------------------------------------------------------------------------------
|
| 277 |
dpurdie |
1055 |
# Function : scan_for_dir
|
|
|
1056 |
#
|
|
|
1057 |
# Description : Scan from the current directory up to the root
|
|
|
1058 |
# of the current file system looking for a named
|
|
|
1059 |
# directory
|
|
|
1060 |
#
|
|
|
1061 |
# Inputs : $target - Directory to locate
|
|
|
1062 |
#
|
|
|
1063 |
# Returns : full_path - Path of dir
|
|
|
1064 |
# full_dir - Containng dir
|
|
|
1065 |
#
|
|
|
1066 |
|
|
|
1067 |
sub scan_for_dir
|
|
|
1068 |
{
|
|
|
1069 |
my ($target) = @_;
|
|
|
1070 |
Verbose2 ("Scan for $target");
|
|
|
1071 |
|
|
|
1072 |
my $test_dir = $CWD;
|
|
|
1073 |
{
|
|
|
1074 |
do
|
|
|
1075 |
{
|
|
|
1076 |
#
|
|
|
1077 |
# Stop at /home to prevent unix automounter spitting
|
|
|
1078 |
# lots of error messages
|
|
|
1079 |
#
|
|
|
1080 |
last if ( $test_dir =~ m~/home$~ );
|
|
|
1081 |
Verbose2 ("Testing: $test_dir");
|
|
|
1082 |
|
|
|
1083 |
my $test_path = $test_dir . '/' . $target;
|
|
|
1084 |
if ( -d $test_path )
|
|
|
1085 |
{
|
|
|
1086 |
Verbose ("Found $target: $test_path");
|
|
|
1087 |
return $test_path, $test_dir;
|
|
|
1088 |
}
|
|
|
1089 |
#
|
|
|
1090 |
# Remove one directory
|
|
|
1091 |
# Terminate the loop when no more can be removed
|
|
|
1092 |
#
|
|
|
1093 |
} while ( $test_dir =~ s~[/][^/]*$~~ );
|
|
|
1094 |
}
|
|
|
1095 |
return '','';
|
|
|
1096 |
}
|
|
|
1097 |
|
|
|
1098 |
#-------------------------------------------------------------------------------
|
| 227 |
dpurdie |
1099 |
# Function : get_java_home
|
|
|
1100 |
#
|
|
|
1101 |
# Description : Convert user java option into a full path,or die
|
|
|
1102 |
#
|
|
|
1103 |
# Inputs : User option
|
|
|
1104 |
#
|
|
|
1105 |
# Returns : Full path
|
|
|
1106 |
#
|
|
|
1107 |
sub get_java_home
|
|
|
1108 |
{
|
|
|
1109 |
my ($java) = @_;
|
|
|
1110 |
my $jv = "JAVA_HOME_$java";
|
|
|
1111 |
$jv =~ s~\.~_~g;
|
|
|
1112 |
|
|
|
1113 |
unless ( exists($ENV{$jv}) )
|
|
|
1114 |
{
|
|
|
1115 |
Error ("Unknown JAVA version: $java",
|
|
|
1116 |
"Looking for EnvVar: $jv",
|
|
|
1117 |
"Example Usage: -java=1.5");
|
|
|
1118 |
}
|
|
|
1119 |
my $rv = $ENV{$jv};
|
|
|
1120 |
unless ( -d $rv )
|
|
|
1121 |
{
|
|
|
1122 |
Error ("Java home path not found: $jv",
|
|
|
1123 |
"Looking for: $rv" );
|
|
|
1124 |
}
|
|
|
1125 |
return $rv;
|
|
|
1126 |
}
|
|
|
1127 |
|
|
|
1128 |
#-------------------------------------------------------------------------------
|
|
|
1129 |
# Function : get_version
|
|
|
1130 |
#
|
|
|
1131 |
# Description : Return the version of JATS being run
|
|
|
1132 |
# JATS should be run from a "package"
|
|
|
1133 |
# The package should have a descpkg file
|
|
|
1134 |
# Use this file
|
|
|
1135 |
#
|
|
|
1136 |
# Inputs :
|
|
|
1137 |
#
|
|
|
1138 |
# Returns : A string
|
|
|
1139 |
#
|
|
|
1140 |
sub get_version
|
|
|
1141 |
{
|
| 229 |
dpurdie |
1142 |
#
|
|
|
1143 |
# The version number is embedded into this script by the release process
|
|
|
1144 |
# The text [V]ERSION_TAG will be replaced by the real version number
|
| 245 |
dpurdie |
1145 |
# If this has not occurred then we know that the release is not official
|
| 229 |
dpurdie |
1146 |
# Need to be a little bit careful about the tag name
|
|
|
1147 |
#
|
|
|
1148 |
return ("Unreleased Version. Version tag has not been set")
|
|
|
1149 |
if ( $GBE_NOT_RELEASED );
|
|
|
1150 |
|
| 227 |
dpurdie |
1151 |
return "$GBE_VERSION [ Internal. Not an installed package ]"
|
|
|
1152 |
if ( ! -f "$GBE_CORE/descpkg" );
|
|
|
1153 |
|
|
|
1154 |
my $rec;
|
|
|
1155 |
return $rec->{'VERSION_FULL'}
|
|
|
1156 |
if ($rec = ReadDescpkg ( "$GBE_CORE/descpkg" ) );
|
|
|
1157 |
|
|
|
1158 |
return "ERROR";
|
|
|
1159 |
}
|
|
|
1160 |
|
|
|
1161 |
#-------------------------------------------------------------------------------
|
|
|
1162 |
# Function : print_version
|
|
|
1163 |
#
|
|
|
1164 |
# Description :
|
|
|
1165 |
#
|
|
|
1166 |
# Inputs :
|
|
|
1167 |
#
|
|
|
1168 |
# Returns :
|
|
|
1169 |
#
|
|
|
1170 |
sub print_version
|
|
|
1171 |
{
|
|
|
1172 |
#
|
|
|
1173 |
# Allow user to specify verboseness as an argument
|
|
|
1174 |
#
|
|
|
1175 |
foreach ( @_ )
|
|
|
1176 |
{
|
|
|
1177 |
$GBE_VERBOSE++ if ( m/^-v/ );
|
|
|
1178 |
}
|
|
|
1179 |
|
|
|
1180 |
Message get_version();
|
|
|
1181 |
Message "Internal: $GBE_VERSION" if ($GBE_VERBOSE);
|
|
|
1182 |
$opr_done = 1;
|
| 283 |
dpurdie |
1183 |
return;
|
| 227 |
dpurdie |
1184 |
}
|
|
|
1185 |
|
|
|
1186 |
|
|
|
1187 |
#-------------------------------------------------------------------------------
|
|
|
1188 |
#
|
|
|
1189 |
# Give the user a clue
|
|
|
1190 |
#
|
|
|
1191 |
sub help
|
|
|
1192 |
{
|
|
|
1193 |
my ($level) = @_;
|
|
|
1194 |
$level = $opt_help unless ( $level );
|
|
|
1195 |
|
|
|
1196 |
pod2usage(-verbose => 0, -message => "Version: ". get_version()) if ($level == 1 );
|
| 261 |
dpurdie |
1197 |
pod2usage(-verbose => $level - 1 );
|
| 227 |
dpurdie |
1198 |
}
|
|
|
1199 |
|
|
|
1200 |
#-------------------------------------------------------------------------------
|
|
|
1201 |
#
|
|
|
1202 |
# Find a JATS build directory
|
|
|
1203 |
# Find a JATS build directory based on file $1
|
|
|
1204 |
#
|
| 295 |
dpurdie |
1205 |
# Will 'cd' to the build directory
|
|
|
1206 |
#
|
| 227 |
dpurdie |
1207 |
sub find_jats_dir
|
|
|
1208 |
{
|
|
|
1209 |
#
|
|
|
1210 |
# Autodetect suppressed ?
|
|
|
1211 |
#
|
|
|
1212 |
return if ( $opt_here );
|
|
|
1213 |
|
|
|
1214 |
my (@FILES) = @_;
|
|
|
1215 |
push @FILES, @BUILD_FILE_ALT;
|
|
|
1216 |
|
|
|
1217 |
my @SEARCH = qw( . .. ../.. ../../.. );
|
|
|
1218 |
|
|
|
1219 |
#
|
|
|
1220 |
# Locate the JATS build files
|
|
|
1221 |
# Allow the user to be in a number of parent directories
|
|
|
1222 |
#
|
|
|
1223 |
for my $ROOTDIR (@SEARCH)
|
|
|
1224 |
{
|
|
|
1225 |
for my $SUBDIR ( '', '/jats', '/build', '/build/jats' )
|
|
|
1226 |
{
|
|
|
1227 |
my $DIR = $ROOTDIR . $SUBDIR;
|
|
|
1228 |
next unless -d $DIR;
|
|
|
1229 |
|
| 283 |
dpurdie |
1230 |
for my $FILE ( @FILES)
|
| 227 |
dpurdie |
1231 |
{
|
|
|
1232 |
my $check_file = $DIR . '/' . $FILE;
|
|
|
1233 |
Verbose2 ("Check for: $check_file");
|
|
|
1234 |
if ( -f $check_file )
|
|
|
1235 |
{
|
|
|
1236 |
change_dir ( $DIR );
|
|
|
1237 |
Verbose2 ("Found: $check_file");
|
|
|
1238 |
return;
|
|
|
1239 |
}
|
|
|
1240 |
}
|
|
|
1241 |
}
|
|
|
1242 |
}
|
|
|
1243 |
Error ("JATS directory not found. Cannot locate: @FILES");
|
|
|
1244 |
}
|
|
|
1245 |
|
|
|
1246 |
#-------------------------------------------------------------------------------
|
|
|
1247 |
#
|
| 295 |
dpurdie |
1248 |
# Determine the real build file to use
|
|
|
1249 |
# Will select from a list of known build files.
|
| 227 |
dpurdie |
1250 |
#
|
| 295 |
dpurdie |
1251 |
sub getBuildFile
|
| 227 |
dpurdie |
1252 |
{
|
|
|
1253 |
my $build_file = $BUILD_FILE;
|
|
|
1254 |
#
|
|
|
1255 |
# Use an alternative buildfile - if it exists
|
|
|
1256 |
# Do not use this file if the user has specified a buildfile
|
|
|
1257 |
#
|
|
|
1258 |
unless ( $BUILD_FILE_SET )
|
|
|
1259 |
{
|
|
|
1260 |
Verbose ("Search for alternate build file");
|
|
|
1261 |
foreach my $test_file ( @BUILD_FILE_ALT )
|
|
|
1262 |
{
|
|
|
1263 |
Verbose2 ("Search for alternate build file: $test_file");
|
|
|
1264 |
if ( -f $test_file )
|
|
|
1265 |
{
|
|
|
1266 |
$build_file = $test_file;
|
|
|
1267 |
Message ("=== USING ALTERNATE BUILDFILE: $build_file ===");
|
|
|
1268 |
last;
|
|
|
1269 |
}
|
|
|
1270 |
}
|
|
|
1271 |
}
|
| 295 |
dpurdie |
1272 |
return $build_file;
|
|
|
1273 |
}
|
| 227 |
dpurdie |
1274 |
|
| 295 |
dpurdie |
1275 |
#-------------------------------------------------------------------------------
|
|
|
1276 |
#
|
|
|
1277 |
# Kick off the build process
|
|
|
1278 |
#
|
|
|
1279 |
sub build
|
|
|
1280 |
{
|
|
|
1281 |
my $build_file = $BUILD_FILE;
|
|
|
1282 |
(my $name = $CWD) =~ s~^.*/~~ ;
|
|
|
1283 |
$opr_done = 1;
|
|
|
1284 |
|
|
|
1285 |
find_jats_dir($build_file);
|
|
|
1286 |
Message ("=== Building $name ===");
|
|
|
1287 |
$build_file = getBuildFile();
|
|
|
1288 |
|
| 227 |
dpurdie |
1289 |
#
|
|
|
1290 |
# Jats/make does not handle file systems with spaces in the path names
|
|
|
1291 |
#
|
|
|
1292 |
Error('$CWD path cannot contain spaces') if ( $CWD =~ m/\s/ );
|
|
|
1293 |
|
|
|
1294 |
$RESULT = System ($GBE_PERL, $build_file, $CWD, "$GBE_TOOLS/buildlib.pl", "--project", @_ );
|
|
|
1295 |
|
| 283 |
dpurdie |
1296 |
Message ("=== Build $name NOT complete ===") if ( $RESULT );
|
|
|
1297 |
Message ("=== Build $name complete ===") unless ( $RESULT );
|
| 227 |
dpurdie |
1298 |
return $RESULT
|
|
|
1299 |
}
|
|
|
1300 |
|
|
|
1301 |
#-------------------------------------------------------------------------------
|
|
|
1302 |
# Function : bmake_it
|
|
|
1303 |
#
|
|
|
1304 |
# Description : Combo build and make operations
|
|
|
1305 |
#
|
|
|
1306 |
# Inputs : ... - COMMANDS or Make arguments.
|
|
|
1307 |
# Key commands are BUILD and INSTALL
|
|
|
1308 |
#
|
|
|
1309 |
# Returns : RESULT code
|
|
|
1310 |
#
|
|
|
1311 |
sub bmake_it
|
|
|
1312 |
{
|
|
|
1313 |
my @make_args = @_;
|
|
|
1314 |
my $all = 1;
|
|
|
1315 |
my $msg;
|
|
|
1316 |
$opr_done = 1;
|
|
|
1317 |
|
|
|
1318 |
if ( $make_args[0] && $make_args[0] eq 'NOTALL' )
|
|
|
1319 |
{
|
|
|
1320 |
$all = 0;
|
|
|
1321 |
shift @make_args;
|
|
|
1322 |
}
|
|
|
1323 |
elsif ( $make_args[0] && $make_args[0] eq 'BUILD' )
|
|
|
1324 |
{
|
|
|
1325 |
Verbose ("Makeit build") ;
|
|
|
1326 |
$msg = "Component not built";
|
|
|
1327 |
build();
|
|
|
1328 |
shift @make_args;
|
|
|
1329 |
}
|
|
|
1330 |
|
|
|
1331 |
unless ( $RESULT )
|
|
|
1332 |
{
|
|
|
1333 |
push @make_args, '-default=all' if ( $all );
|
|
|
1334 |
Verbose ("Makeit make @make_args") ;
|
|
|
1335 |
|
|
|
1336 |
find_jats_dir( "makefile.pl", "Makefile.gbe", $BUILD_FILE );
|
|
|
1337 |
Error ("No Makefile.gbe file found") unless ( -f 'Makefile.gbe' );
|
|
|
1338 |
|
|
|
1339 |
etool ( 'jmake.pl', @make_args );
|
|
|
1340 |
$msg = "Component not made";
|
|
|
1341 |
@make_args = ();
|
|
|
1342 |
}
|
|
|
1343 |
|
|
|
1344 |
|
|
|
1345 |
Verbose ("Makeit Result: $RESULT") ;
|
|
|
1346 |
Error ( $msg ) if ( $RESULT );
|
|
|
1347 |
return if ( $RESULT );
|
|
|
1348 |
}
|
|
|
1349 |
|
|
|
1350 |
#-------------------------------------------------------------------------------
|
|
|
1351 |
# Function : dev_expand
|
|
|
1352 |
#
|
|
|
1353 |
# Description : Expand the users arguments to the "debug/prod" command
|
|
|
1354 |
# "debug/prod" builds and packages debug stuff
|
|
|
1355 |
#
|
|
|
1356 |
# Ignore make options.
|
|
|
1357 |
#
|
|
|
1358 |
# Inputs : target
|
|
|
1359 |
# Argument list
|
|
|
1360 |
#
|
|
|
1361 |
# Returns : expanded argument list
|
|
|
1362 |
#
|
|
|
1363 |
sub dev_expand
|
|
|
1364 |
{
|
|
|
1365 |
my @resultd;
|
|
|
1366 |
my @resultp;
|
|
|
1367 |
my @args;
|
|
|
1368 |
my @opts;
|
|
|
1369 |
|
|
|
1370 |
#
|
|
|
1371 |
# Remove options from the argument list
|
|
|
1372 |
#
|
|
|
1373 |
foreach ( @_ )
|
|
|
1374 |
{
|
|
|
1375 |
if ( m~=~ || m~^-~ ) {
|
|
|
1376 |
push @opts, $_;
|
|
|
1377 |
} else {
|
|
|
1378 |
push @args, $_;
|
|
|
1379 |
}
|
|
|
1380 |
}
|
|
|
1381 |
|
|
|
1382 |
my $target = shift @args;
|
|
|
1383 |
my @cmd = $target;
|
|
|
1384 |
if ( $#args < 0 )
|
|
|
1385 |
{
|
|
|
1386 |
push @cmd, "package_$target";
|
|
|
1387 |
}
|
|
|
1388 |
else
|
|
|
1389 |
{
|
|
|
1390 |
foreach ( @args )
|
|
|
1391 |
{
|
|
|
1392 |
push @resultd, $_ . "_$target";
|
|
|
1393 |
push @resultp, $_ . "_package_$target";
|
|
|
1394 |
@cmd = ();
|
|
|
1395 |
}
|
|
|
1396 |
}
|
|
|
1397 |
|
|
|
1398 |
return (@cmd, @resultd, @resultp, @opts);
|
|
|
1399 |
}
|
|
|
1400 |
|
|
|
1401 |
#-------------------------------------------------------------------------------
|
|
|
1402 |
# Function : install_pkg
|
|
|
1403 |
#
|
|
|
1404 |
# Description : Install the built package into local_dpkg_archive
|
|
|
1405 |
# This will make it available for use, without populating the
|
|
|
1406 |
# global archive
|
|
|
1407 |
#
|
|
|
1408 |
# This is done through an external utility to maintain
|
|
|
1409 |
# consistent interface
|
|
|
1410 |
#
|
|
|
1411 |
sub install_pkg
|
|
|
1412 |
{
|
|
|
1413 |
|
|
|
1414 |
find_jats_dir($BUILD_FILE, "build.xml" );
|
|
|
1415 |
etool ( 'create_dpkg.pl', '-archive=local', '-quiet', '-override', @_ );
|
|
|
1416 |
}
|
|
|
1417 |
|
|
|
1418 |
#-------------------------------------------------------------------------------
|
|
|
1419 |
# Function : create_dpkg
|
|
|
1420 |
#
|
|
|
1421 |
# Description : Install a package into the main dpkg_archive
|
|
|
1422 |
# This is done through an external utility to maintain
|
|
|
1423 |
# consistent interface
|
|
|
1424 |
#
|
|
|
1425 |
# This function is simply an easy way to access the utility
|
|
|
1426 |
|
|
|
1427 |
sub create_dpkg
|
|
|
1428 |
{
|
|
|
1429 |
find_jats_dir($BUILD_FILE, "build.xml" );
|
|
|
1430 |
etool ( 'create_dpkg.pl', @_ );
|
|
|
1431 |
}
|
|
|
1432 |
|
|
|
1433 |
#-------------------------------------------------------------------------------
|
|
|
1434 |
# Function : etool
|
|
|
1435 |
#
|
|
|
1436 |
# Description : Invoke an external tool program written in PERL
|
|
|
1437 |
#
|
|
|
1438 |
# Arguments : $1 Name of the program to run
|
|
|
1439 |
# With optional .pl suffix
|
|
|
1440 |
# $2+ Program arguments
|
|
|
1441 |
#
|
|
|
1442 |
sub etool
|
|
|
1443 |
{
|
|
|
1444 |
my $command = shift;
|
|
|
1445 |
my $cmd;
|
|
|
1446 |
my @etool_path = ( "$ENV{'GBE_TOOLS'}",
|
|
|
1447 |
"$ENV{'GBE_TOOLS'}/DEPLOY",
|
|
|
1448 |
"$ENV{'GBE_TOOLS'}/LOCAL" );
|
|
|
1449 |
if ( $command )
|
|
|
1450 |
{
|
|
|
1451 |
#
|
|
|
1452 |
# Locate a potential tool
|
|
|
1453 |
# These will have the user name or a .pl extension
|
|
|
1454 |
#
|
|
|
1455 |
ETOOL_SEARCH:
|
|
|
1456 |
foreach my $ext ( '', '.pl' )
|
|
|
1457 |
{
|
|
|
1458 |
foreach my $dir ( @etool_path )
|
|
|
1459 |
{
|
|
|
1460 |
$cmd = "$dir/$command$ext";
|
|
|
1461 |
last ETOOL_SEARCH if ( -f $cmd );
|
|
|
1462 |
}
|
|
|
1463 |
$cmd='';
|
|
|
1464 |
}
|
|
|
1465 |
|
|
|
1466 |
Error ("Tool not found: $command", "Search path:", @etool_path) unless $cmd;
|
|
|
1467 |
$RESULT = System ( $GBE_PERL, $cmd, @_ );
|
|
|
1468 |
}
|
|
|
1469 |
else
|
|
|
1470 |
{
|
|
|
1471 |
#
|
|
|
1472 |
# Display on the .pl commands
|
|
|
1473 |
#
|
|
|
1474 |
display_commands("Available Tools", \@etool_path, ['*.pl'] );
|
|
|
1475 |
}
|
|
|
1476 |
|
|
|
1477 |
$opr_done = 1;
|
|
|
1478 |
}
|
|
|
1479 |
|
|
|
1480 |
#-------------------------------------------------------------------------------
|
|
|
1481 |
# Function : ebin
|
|
|
1482 |
#
|
|
|
1483 |
# Description : Invoke an external JATS provided binary
|
|
|
1484 |
# within the JATS toolset
|
|
|
1485 |
#
|
|
|
1486 |
# Arguments : $1 Name of the program to run
|
|
|
1487 |
# $2+ Program arguments
|
|
|
1488 |
#
|
|
|
1489 |
sub ebin
|
|
|
1490 |
{
|
|
|
1491 |
my $command = shift;
|
|
|
1492 |
my $cmd;
|
|
|
1493 |
my @ebin_path = ( "$GBE_BIN" );
|
|
|
1494 |
|
|
|
1495 |
if ( $command )
|
|
|
1496 |
{
|
|
|
1497 |
#
|
|
|
1498 |
# Locate a potential executable
|
|
|
1499 |
# This
|
|
|
1500 |
#
|
|
|
1501 |
ETOOL_SEARCH:
|
|
|
1502 |
foreach my $ext ( '', '.exe', '.sh' )
|
|
|
1503 |
{
|
|
|
1504 |
foreach my $dir ( @ebin_path )
|
|
|
1505 |
{
|
|
|
1506 |
$cmd = "$dir/$command$ext";
|
|
|
1507 |
last ETOOL_SEARCH if ( -f $cmd );
|
|
|
1508 |
}
|
|
|
1509 |
$cmd='';
|
|
|
1510 |
}
|
|
|
1511 |
|
|
|
1512 |
Error ("Program not found: $command", "Search path:", @ebin_path) unless $cmd;
|
|
|
1513 |
$RESULT = System ( $cmd, @_ );
|
|
|
1514 |
}
|
|
|
1515 |
else
|
|
|
1516 |
{
|
|
|
1517 |
#
|
|
|
1518 |
# Display a list of programs
|
|
|
1519 |
#
|
|
|
1520 |
display_commands("Available Programs", \@ebin_path, ['*'] );
|
|
|
1521 |
}
|
|
|
1522 |
|
|
|
1523 |
$opr_done = 1;
|
|
|
1524 |
}
|
|
|
1525 |
|
|
|
1526 |
#-------------------------------------------------------------------------------
|
|
|
1527 |
# Function : eprog
|
|
|
1528 |
#
|
|
|
1529 |
# Description : Invoke an external program
|
|
|
1530 |
# Will detect local .pl files and execute them
|
|
|
1531 |
# Will detect local .jar files and execute them
|
| 229 |
dpurdie |
1532 |
# Will detect local .bat files and execute them
|
| 227 |
dpurdie |
1533 |
#
|
|
|
1534 |
# Arguments : $1 Name of the program to run
|
|
|
1535 |
# $2+ Program arguments
|
|
|
1536 |
#
|
|
|
1537 |
sub eprog
|
|
|
1538 |
{
|
| 229 |
dpurdie |
1539 |
Verbose ("eprog: @_");
|
| 227 |
dpurdie |
1540 |
my $name = shift @_;
|
|
|
1541 |
Error ("eprog. No program specified") unless ( $name );
|
|
|
1542 |
|
| 229 |
dpurdie |
1543 |
$name .= ".pl" if ( -f "${name}.pl" );
|
|
|
1544 |
$name .= ".jar" if ( -f "${name}.jar" );
|
|
|
1545 |
$name .= ".bat" if ( -f "${name}.bat" );
|
| 227 |
dpurdie |
1546 |
|
| 229 |
dpurdie |
1547 |
#
|
| 245 |
dpurdie |
1548 |
# On Windows programs in the CWD will be found
|
|
|
1549 |
# Mimic this behaviour on Unix
|
| 229 |
dpurdie |
1550 |
#
|
|
|
1551 |
$name = "./$name" if ( $name !~ m~/~ && -f "./$name");
|
|
|
1552 |
|
| 227 |
dpurdie |
1553 |
if ( $name =~ m~\.pl$~ ) {
|
|
|
1554 |
$RESULT = System ( $GBE_PERL, $name, @_ );
|
|
|
1555 |
|
|
|
1556 |
} elsif ( $name =~ m~\.jar$~ ) {
|
|
|
1557 |
$RESULT = System ( "$JAVA_HOME/bin/java", '-jar', $name, @_);
|
|
|
1558 |
|
|
|
1559 |
} else {
|
| 229 |
dpurdie |
1560 |
#
|
|
|
1561 |
# Ensure .bat files are pathed with \, and not / characters
|
|
|
1562 |
# The windows command interpreter does not like /
|
|
|
1563 |
#
|
|
|
1564 |
$name =~ s~/~\\~g if ( $name =~ m~\.bat$~ );
|
|
|
1565 |
|
| 227 |
dpurdie |
1566 |
$RESULT = System ( $name, @_ );
|
|
|
1567 |
}
|
|
|
1568 |
|
|
|
1569 |
$opr_done = 1;
|
|
|
1570 |
}
|
|
|
1571 |
|
|
|
1572 |
#-------------------------------------------------------------------------------
|
|
|
1573 |
# Function : display_commands
|
|
|
1574 |
#
|
|
|
1575 |
# Description : Display a list of commands from a specified list of dirs
|
|
|
1576 |
# Internal helper function
|
|
|
1577 |
#
|
|
|
1578 |
# Inputs : $title - Display header
|
|
|
1579 |
# $ref_path - Ref to an array that contains the search path
|
|
|
1580 |
# $ref_ext - Ref to an array of valid patterns
|
|
|
1581 |
#
|
|
|
1582 |
# Returns : Nothing
|
|
|
1583 |
#
|
|
|
1584 |
sub display_commands
|
|
|
1585 |
{
|
|
|
1586 |
my ( $title, $ref_path, $ref_ext ) = @_;
|
|
|
1587 |
|
|
|
1588 |
#
|
|
|
1589 |
# Display a list of commands
|
|
|
1590 |
#
|
|
|
1591 |
my %list;
|
|
|
1592 |
foreach ( @$ref_path )
|
|
|
1593 |
{
|
|
|
1594 |
foreach my $ext ( @$ref_ext )
|
|
|
1595 |
{
|
|
|
1596 |
foreach my $file ( glob( "$_/$ext") )
|
|
|
1597 |
{
|
|
|
1598 |
$file =~ s~.*/~~ unless $GBE_VERBOSE;
|
|
|
1599 |
$list{$file} = 1;
|
|
|
1600 |
}
|
|
|
1601 |
}
|
|
|
1602 |
}
|
|
|
1603 |
|
|
|
1604 |
my $count = 0;
|
|
|
1605 |
my $limit = $GBE_VERBOSE ? 1 : 3;
|
|
|
1606 |
print "$title:\n";
|
|
|
1607 |
foreach ( sort keys %list )
|
|
|
1608 |
{
|
|
|
1609 |
printf "%-26s", $_;
|
|
|
1610 |
print "\n" if ( !( ++$count % $limit) );
|
|
|
1611 |
}
|
|
|
1612 |
}
|
|
|
1613 |
|
|
|
1614 |
#-------------------------------------------------------------------------------
|
|
|
1615 |
# Function : run_ant
|
|
|
1616 |
#
|
|
|
1617 |
# Description : Invoke ant
|
|
|
1618 |
# If the current directory looks like an ERG build system, then
|
|
|
1619 |
# create and maintain an auto.xml file. Otherwise simply invoke ant
|
|
|
1620 |
#
|
|
|
1621 |
# Inputs : $1+ program arguments
|
|
|
1622 |
#
|
|
|
1623 |
sub run_ant
|
|
|
1624 |
{
|
|
|
1625 |
my $JAVA_HOME = $ENV{JAVA_HOME} || Error ("JAVA_HOME is not defined in the environment");
|
|
|
1626 |
my $ANT_HOME = $ENV{ANT_HOME} || Error ("ANT_HOME is not defined in the environment" );
|
|
|
1627 |
|
|
|
1628 |
#
|
|
|
1629 |
# Detect an ERG formatted build
|
|
|
1630 |
# This will have two files <projectname>.xml and <projectname>depends.xml
|
|
|
1631 |
# Create the 'auto.xml' file only if its not present
|
|
|
1632 |
#
|
|
|
1633 |
my @ant_arg;
|
|
|
1634 |
my @flist;
|
|
|
1635 |
my $basename = '';
|
| 235 |
dpurdie |
1636 |
my $scanner = '*depends.xml';
|
| 227 |
dpurdie |
1637 |
|
|
|
1638 |
#
|
|
|
1639 |
# Use specified build file to resolve multiple names
|
|
|
1640 |
# Strip any trailing depends.xml to make it user friendly
|
|
|
1641 |
#
|
|
|
1642 |
if ( $BUILD_FILE_SET )
|
|
|
1643 |
{
|
|
|
1644 |
$basename = $BUILD_FILE;
|
|
|
1645 |
$basename =~ s~\.xml$~~;
|
|
|
1646 |
$basename =~ s~depends$~~;
|
| 235 |
dpurdie |
1647 |
$scanner = "${basename}depends.xml";
|
| 227 |
dpurdie |
1648 |
Verbose ("Using buildfile: $basename");
|
|
|
1649 |
}
|
|
|
1650 |
|
| 235 |
dpurdie |
1651 |
my @buildlist = glob($scanner);
|
| 227 |
dpurdie |
1652 |
foreach ( @buildlist )
|
|
|
1653 |
{
|
|
|
1654 |
if ( m/(.+)depends.xml/ )
|
|
|
1655 |
{
|
|
|
1656 |
my $pname = $1;
|
|
|
1657 |
push @flist, $pname if ( -f "$pname.xml" );
|
|
|
1658 |
}
|
|
|
1659 |
}
|
|
|
1660 |
|
|
|
1661 |
if ( $#flist >= 0 )
|
|
|
1662 |
{
|
|
|
1663 |
Error ("Multiple depends.xml files found:", @flist,
|
|
|
1664 |
"Use -buildfile=name to resolve") if ( $#flist > 0 );
|
|
|
1665 |
|
|
|
1666 |
my $depend = "$flist[0]depends.xml";
|
|
|
1667 |
@ant_arg = ('-f', "$flist[0].xml");
|
|
|
1668 |
|
|
|
1669 |
Message ("Ant using projectfiles: $flist[0].xml");
|
|
|
1670 |
|
|
|
1671 |
#
|
|
|
1672 |
# Check for depends.xml newer than auto.xml.
|
|
|
1673 |
#
|
|
|
1674 |
my $auto_timestamp = (stat('auto.xml'))[9] || 0;
|
|
|
1675 |
my $depend_timestamp = (stat($depend))[9];
|
|
|
1676 |
if ( $depend_timestamp > $auto_timestamp )
|
|
|
1677 |
{
|
|
|
1678 |
Message ("Creating: auto.xml");
|
|
|
1679 |
copy( $depend, 'auto.xml' );
|
|
|
1680 |
chmod 0777, 'auto.xml';
|
|
|
1681 |
}
|
|
|
1682 |
}
|
|
|
1683 |
elsif ( $BUILD_FILE_SET )
|
|
|
1684 |
{
|
|
|
1685 |
Error ("Specified build file pair not found:", $basename, $basename . "depends.xml");
|
|
|
1686 |
}
|
|
|
1687 |
|
|
|
1688 |
#
|
|
|
1689 |
# The ant provided startup scripts don't return an exit code under
|
|
|
1690 |
# windows. Invoke ant directly
|
|
|
1691 |
#
|
|
|
1692 |
launch_ant ( $JAVA_HOME, $ANT_HOME, @ant_arg, @_ );
|
|
|
1693 |
$opr_done = 1;
|
|
|
1694 |
}
|
|
|
1695 |
|
|
|
1696 |
#-------------------------------------------------------------------------------
|
|
|
1697 |
# Function : run_abt
|
|
|
1698 |
#
|
|
|
1699 |
# Description : Invoke auto build tool (older form)
|
|
|
1700 |
# Options for the ABT
|
|
|
1701 |
# --Java=x.x
|
|
|
1702 |
# Invoke ANT for the ABT using a specified version of Java
|
|
|
1703 |
# Do not play with the user environment.
|
|
|
1704 |
#
|
|
|
1705 |
# Inputs : $1+ program arguments
|
|
|
1706 |
#
|
|
|
1707 |
sub run_abt
|
|
|
1708 |
{
|
| 279 |
dpurdie |
1709 |
my $ABT_JAVA = 'JAVA_HOME_1_6'; # Default version for the ABT
|
| 227 |
dpurdie |
1710 |
my $JAVA_HOME = $ENV{$ABT_JAVA};
|
|
|
1711 |
my $ANT_HOME = $ENV{ANT_HOME};
|
|
|
1712 |
my @abt_arg;
|
| 239 |
dpurdie |
1713 |
my $buildfile = 'build.xml';
|
| 227 |
dpurdie |
1714 |
|
|
|
1715 |
ErrorConfig( 'name' => 'JATS ABT' );
|
|
|
1716 |
|
|
|
1717 |
#
|
| 239 |
dpurdie |
1718 |
# Use the user specified buildfile
|
|
|
1719 |
#
|
|
|
1720 |
$buildfile = $BUILD_FILE
|
|
|
1721 |
if ( $BUILD_FILE_SET );
|
|
|
1722 |
|
|
|
1723 |
#
|
| 227 |
dpurdie |
1724 |
# Extract known options
|
|
|
1725 |
#
|
|
|
1726 |
foreach ( @_ )
|
|
|
1727 |
{
|
|
|
1728 |
if ( m/-java=(.*)/ ) {
|
|
|
1729 |
$JAVA_HOME = get_java_home($1);
|
| 239 |
dpurdie |
1730 |
|
|
|
1731 |
} elsif ( m/^-buildfile=(.+)/ ) {
|
|
|
1732 |
$buildfile = $1;
|
|
|
1733 |
|
| 227 |
dpurdie |
1734 |
} else {
|
|
|
1735 |
push @abt_arg, $_;
|
|
|
1736 |
}
|
|
|
1737 |
}
|
|
|
1738 |
|
|
|
1739 |
Error ("$ABT_JAVA is not defined in the environment") unless $JAVA_HOME;
|
|
|
1740 |
Error ("ANT_HOME is not defined in the environment" ) unless $ANT_HOME;
|
| 239 |
dpurdie |
1741 |
Error ("Ant buildfile not found: $buildfile" ) unless (-f $buildfile);
|
| 227 |
dpurdie |
1742 |
|
|
|
1743 |
#
|
| 239 |
dpurdie |
1744 |
# Insert correct build file arguments
|
|
|
1745 |
#
|
| 279 |
dpurdie |
1746 |
push @abt_arg, '-buildfile', $buildfile;
|
|
|
1747 |
|
|
|
1748 |
#
|
|
|
1749 |
# Add current directory as java library directory, but only if
|
|
|
1750 |
# it contains JAR files.
|
|
|
1751 |
#
|
|
|
1752 |
push @abt_arg, '-lib', $CWD
|
|
|
1753 |
if ( glob ('*.jar') );
|
| 239 |
dpurdie |
1754 |
|
|
|
1755 |
#
|
| 227 |
dpurdie |
1756 |
# Use the ant-launcher to invoke ant directly
|
|
|
1757 |
#
|
|
|
1758 |
launch_ant ( $JAVA_HOME, $ANT_HOME, @abt_arg );
|
|
|
1759 |
$opr_done = 1;
|
|
|
1760 |
}
|
|
|
1761 |
|
|
|
1762 |
#-------------------------------------------------------------------------------
|
|
|
1763 |
# Function : launch_ant
|
|
|
1764 |
#
|
|
|
1765 |
# Description : Start ANT - with sanity checking
|
|
|
1766 |
#
|
|
|
1767 |
# Inputs : JAVA_HOME
|
|
|
1768 |
# ANT_HOME
|
|
|
1769 |
# @user_args
|
|
|
1770 |
#
|
|
|
1771 |
# Returns : Result Code
|
|
|
1772 |
#
|
|
|
1773 |
sub launch_ant
|
|
|
1774 |
{
|
|
|
1775 |
my ($JAVA_HOME, $ANT_HOME, @user_args ) = @_;
|
|
|
1776 |
|
|
|
1777 |
Error ("Directory not found: $JAVA_HOME") unless ( -d "$JAVA_HOME" );
|
|
|
1778 |
Error ("Program not found: $JAVA_HOME/bin/java") unless ( -e "$JAVA_HOME/bin/java" || -e "$JAVA_HOME/bin/java.exe" );
|
|
|
1779 |
Error ("Jar not found: $ANT_HOME/lib/ant-launcher.jar") unless ( -e "$ANT_HOME/lib/ant-launcher.jar" );
|
|
|
1780 |
Error ("Directory not found: $ANT_HOME") unless ( -d "$ANT_HOME" );
|
|
|
1781 |
Error ("Directory not found: $ANT_HOME/lib") unless ( -d "$ANT_HOME/lib" );
|
|
|
1782 |
|
|
|
1783 |
#
|
|
|
1784 |
# Use the ant-launcher to invoke ant directly
|
|
|
1785 |
#
|
|
|
1786 |
$RESULT = System ( "$JAVA_HOME/bin/java",
|
|
|
1787 |
"-classpath","$ANT_HOME/lib/ant-launcher.jar",
|
|
|
1788 |
"-Dant.home=$ANT_HOME",
|
|
|
1789 |
"org.apache.tools.ant.launch.Launcher",
|
|
|
1790 |
"-lib","$ANT_HOME/lib",
|
|
|
1791 |
@user_args
|
|
|
1792 |
);
|
|
|
1793 |
|
|
|
1794 |
return $RESULT;
|
|
|
1795 |
}
|
|
|
1796 |
|
|
|
1797 |
|
|
|
1798 |
#-------------------------------------------------------------------------------
|
|
|
1799 |
#
|
|
|
1800 |
# Cleanup the sandbox
|
|
|
1801 |
# Perform a "make clobber" then a "build clobber"
|
|
|
1802 |
#
|
|
|
1803 |
sub clobber
|
|
|
1804 |
{
|
|
|
1805 |
Message ("=== Removing ======");
|
|
|
1806 |
find_jats_dir( $BUILD_FILE );
|
| 295 |
dpurdie |
1807 |
my $build_file = getBuildFile();
|
|
|
1808 |
|
| 227 |
dpurdie |
1809 |
|
|
|
1810 |
#
|
|
|
1811 |
# Run a "make clobber" to clean out "everything"
|
|
|
1812 |
#
|
|
|
1813 |
etool ( 'jmake.pl', 'clobber' )
|
|
|
1814 |
if ( -f "Makefile.gbe" );
|
|
|
1815 |
|
| 295 |
dpurdie |
1816 |
if ( -f $build_file )
|
| 227 |
dpurdie |
1817 |
{
|
| 295 |
dpurdie |
1818 |
System ( $GBE_PERL, $build_file, $CWD, "$GBE_TOOLS/buildlib.pl", 'clobber' );
|
| 227 |
dpurdie |
1819 |
}
|
|
|
1820 |
else
|
|
|
1821 |
{
|
|
|
1822 |
Error ("Cannot clobber. No buildfile found");
|
|
|
1823 |
}
|
|
|
1824 |
|
|
|
1825 |
Message ("=== Remove complete ===");
|
|
|
1826 |
$opr_done = 1;
|
|
|
1827 |
}
|
|
|
1828 |
|
|
|
1829 |
#-------------------------------------------------------------------------------
|
|
|
1830 |
#
|
|
|
1831 |
# Dumpout relevant parts of the environment
|
|
|
1832 |
#
|
|
|
1833 |
sub dump_vars
|
|
|
1834 |
{
|
|
|
1835 |
$opr_done = 1;
|
|
|
1836 |
|
|
|
1837 |
#
|
|
|
1838 |
# Allow user to specify verboseness as an argument
|
|
|
1839 |
#
|
|
|
1840 |
foreach ( @_ )
|
|
|
1841 |
{
|
|
|
1842 |
$GBE_VERBOSE++ if ( m/^-v/ )
|
|
|
1843 |
}
|
|
|
1844 |
|
|
|
1845 |
# Display an array separated list, one entry per line, with dir sanity check
|
|
|
1846 |
sub alist
|
|
|
1847 |
{
|
|
|
1848 |
my ($text, @var) = @_;
|
|
|
1849 |
my $sep = "=";
|
|
|
1850 |
for ( @var )
|
|
|
1851 |
{
|
|
|
1852 |
my $valid = ( -d $_ || -f $_ ) ? " " : "*";
|
|
|
1853 |
printf "%-17s%s%s%s\n", $text, $sep, $valid, $_;
|
|
|
1854 |
$text = "";
|
|
|
1855 |
$sep = " ";
|
|
|
1856 |
}
|
|
|
1857 |
}
|
|
|
1858 |
|
|
|
1859 |
# Display a ';' or ':' separated list, one entry per line
|
|
|
1860 |
sub dlist
|
|
|
1861 |
{
|
|
|
1862 |
my ($text, $var) = @_;
|
|
|
1863 |
alist( $text, split $PSPLIT, $var || " " );
|
|
|
1864 |
}
|
|
|
1865 |
|
|
|
1866 |
# Simple print of name and variable
|
|
|
1867 |
sub pvar
|
|
|
1868 |
{
|
|
|
1869 |
my ($text, $data) = @_;
|
|
|
1870 |
printf "%-17s= %s\n", $text, $data;
|
|
|
1871 |
}
|
|
|
1872 |
|
|
|
1873 |
# Print of name and variable of directory with sanity check
|
|
|
1874 |
sub dvar
|
|
|
1875 |
{
|
|
|
1876 |
my ($text, $data) = @_;
|
|
|
1877 |
my $valid = ( ! $data || -d $data || -f $data ) ? " " : "*";
|
|
|
1878 |
printf "%-17s=%s%s\n", $text, $valid, $data;
|
|
|
1879 |
}
|
|
|
1880 |
|
|
|
1881 |
# Display a variable extracted from the environment
|
|
|
1882 |
sub penv
|
|
|
1883 |
{
|
|
|
1884 |
my ($var) = @_;
|
|
|
1885 |
pvar $var, $ENV{$var} || '';
|
|
|
1886 |
}
|
|
|
1887 |
|
|
|
1888 |
# Display a variable extracted from the environment with dir sanity check
|
|
|
1889 |
sub denv
|
|
|
1890 |
{
|
|
|
1891 |
my ($var) = @_;
|
|
|
1892 |
dvar $var, $ENV{$var} || '';
|
|
|
1893 |
}
|
|
|
1894 |
|
|
|
1895 |
#
|
|
|
1896 |
# Complete environment dump
|
|
|
1897 |
#
|
|
|
1898 |
if ( $GBE_VERBOSE > 1 )
|
|
|
1899 |
{
|
|
|
1900 |
Message ("Complete environment dump");
|
|
|
1901 |
foreach my $var ( sort keys(%ENV) )
|
|
|
1902 |
{
|
|
|
1903 |
penv $var;
|
|
|
1904 |
}
|
|
|
1905 |
return;
|
|
|
1906 |
}
|
|
|
1907 |
|
|
|
1908 |
pvar "Version" , get_version();
|
|
|
1909 |
penv "GBE_SCRIPT";
|
|
|
1910 |
pvar "GBE_DEBUG" , $GBE_DEBUG;
|
|
|
1911 |
pvar "GBE_VERBOSE" , $GBE_VERBOSE;
|
|
|
1912 |
pvar "GBE_MACHTYPE" , $GBE_MACHTYPE;
|
| 273 |
dpurdie |
1913 |
pvar "GBE_HOSTMACH" , $GBE_HOSTMACH;
|
| 227 |
dpurdie |
1914 |
pvar "GBE_UNIX" , $GBE_UNIX;
|
|
|
1915 |
pvar "GBE_DRV" , $GBE_DRV;
|
|
|
1916 |
dvar "GBE_PERL" , $GBE_PERL;
|
|
|
1917 |
dvar "GBE_CORE" , $GBE_CORE;
|
|
|
1918 |
dvar "GBE_BIN" , $GBE_BIN;
|
|
|
1919 |
dvar "GBE_TOOLS" , $GBE_TOOLS;
|
|
|
1920 |
dvar "GBE_CONFIG" , $GBE_CONFIG;
|
|
|
1921 |
penv "GBE_CACHE_JATS";
|
|
|
1922 |
dlist "GBE_SANDBOX" , $GBE_SANDBOX;
|
|
|
1923 |
dlist "GBE_DPKG_STORE" , $GBE_DPKG_STORE;
|
|
|
1924 |
dlist "GBE_DPKG" , $GBE_DPKG;
|
|
|
1925 |
dlist "GBE_DPKG_CACHE" , $GBE_DPKG_CACHE;
|
|
|
1926 |
dlist "GBE_DPKG_LOCAL" , $GBE_DPKG_LOCAL;
|
|
|
1927 |
dlist "GBE_DPKG_SBOX" , $GBE_DPKG_SBOX;
|
|
|
1928 |
dlist "GBE_DPLY" , $GBE_DPLY;
|
|
|
1929 |
pvar "GBE_PLATFORM" , $GBE_PLATFORM;
|
|
|
1930 |
pvar "GBE_BUILDFILTER" , $GBE_BUILDFILTER;
|
|
|
1931 |
pvar "GBE_ABT" , $GBE_ABT;
|
|
|
1932 |
|
|
|
1933 |
denv "GBE_VIEWBASE";
|
| 281 |
dpurdie |
1934 |
pvar "GBE_HOSTNAME" , $GBE_HOSTNAME;
|
| 227 |
dpurdie |
1935 |
dvar "CWD" , $CWD;
|
|
|
1936 |
pvar "BUILD_FILE" , $BUILD_FILE;
|
|
|
1937 |
|
|
|
1938 |
penv "COMSPEC";
|
|
|
1939 |
penv "SHELL";
|
|
|
1940 |
pvar "USER" , $USER;
|
|
|
1941 |
dlist "PATH" , $PATH;
|
|
|
1942 |
|
|
|
1943 |
#
|
|
|
1944 |
# Display variables used by various "known" toolsets
|
|
|
1945 |
# These do cause grief sometime, so only do it for verbose
|
|
|
1946 |
#
|
|
|
1947 |
if ( $GBE_VERBOSE )
|
|
|
1948 |
{
|
|
|
1949 |
print "\nPerl Environment\n";
|
|
|
1950 |
pvar "VERSION" ,$];
|
|
|
1951 |
penv "PERL5SHELL";
|
|
|
1952 |
penv "PERL5OPT";
|
|
|
1953 |
dlist "PERL5LIB" ,$ENV{'PERL5LIB'};
|
|
|
1954 |
alist "INC" ,@INC;
|
|
|
1955 |
|
|
|
1956 |
print "\nJava Environment\n";
|
| 283 |
dpurdie |
1957 |
foreach my $var ( sort grep ( {/^JAVA_HOME/ } keys %ENV) )
|
| 227 |
dpurdie |
1958 |
{
|
|
|
1959 |
denv $var;
|
|
|
1960 |
}
|
|
|
1961 |
denv "ANT_HOME";
|
|
|
1962 |
denv "JATS_HOME";
|
|
|
1963 |
dlist "CLASSPATH" ,$ENV{'CLASSPATH'};
|
|
|
1964 |
}
|
|
|
1965 |
|
|
|
1966 |
if ( $GBE_VERBOSE || $GBE_ABT )
|
|
|
1967 |
{
|
|
|
1968 |
print "\nRelease Manager Environment\n";
|
|
|
1969 |
penv "GBE_RM_LOCATION";
|
|
|
1970 |
penv "GBE_RM_USERNAME";
|
|
|
1971 |
penv "GBE_RM_PASSWORD";
|
|
|
1972 |
penv "GBE_RM_URL";
|
|
|
1973 |
penv "GBE_DM_LOCATION";
|
|
|
1974 |
penv "GBE_DM_USERNAME";
|
|
|
1975 |
penv "GBE_DM_PASSWORD";
|
|
|
1976 |
penv "GBE_DM_URL";
|
|
|
1977 |
}
|
|
|
1978 |
|
|
|
1979 |
if ( $GBE_VERBOSE && ! $GBE_UNIX)
|
|
|
1980 |
{
|
|
|
1981 |
print "\nWindows Environment\n";
|
|
|
1982 |
denv "TEMP";
|
|
|
1983 |
denv "TMP";
|
|
|
1984 |
|
|
|
1985 |
print "\nMicrosoft Studio Variables\n";
|
|
|
1986 |
denv "PROGRAMFILES";
|
|
|
1987 |
denv "WINDIR";
|
|
|
1988 |
denv "MSVCDir";
|
|
|
1989 |
|
|
|
1990 |
print "\nMicroTec Compiler Variables\n";
|
|
|
1991 |
denv "MRI_68K";
|
|
|
1992 |
denv "MRI_CF";
|
|
|
1993 |
denv "VISIONCLICK";
|
|
|
1994 |
|
|
|
1995 |
print "\nPCLint Variables\n";
|
|
|
1996 |
denv "PCLINT";
|
|
|
1997 |
penv "LINTPACKAGE";
|
|
|
1998 |
}
|
|
|
1999 |
}
|
|
|
2000 |
|
|
|
2001 |
#-------------------------------------------------------------------------------
|
|
|
2002 |
# Function : do_exit
|
|
|
2003 |
#
|
|
|
2004 |
# Description : Common exit point so that time information can be displayed
|
|
|
2005 |
#
|
|
|
2006 |
# Inputs : Optional exit code
|
|
|
2007 |
#
|
|
|
2008 |
# Returns :
|
|
|
2009 |
#
|
|
|
2010 |
sub do_exit
|
|
|
2011 |
{
|
|
|
2012 |
my ($ecode) = @_;
|
|
|
2013 |
|
|
|
2014 |
$RESULT = $ecode if ( $ecode );
|
|
|
2015 |
|
|
|
2016 |
#..
|
|
|
2017 |
# Determine the runtime
|
|
|
2018 |
#
|
|
|
2019 |
if ( $opt_time )
|
|
|
2020 |
{
|
|
|
2021 |
my ($TIMEU, $TIMES) = times;
|
|
|
2022 |
$TIMER = time - $TIMER;
|
|
|
2023 |
my ($m, $s );
|
|
|
2024 |
|
|
|
2025 |
$m = int($TIMER / 60);
|
|
|
2026 |
$s = $TIMER - ($m * 60);
|
|
|
2027 |
|
|
|
2028 |
Message ( "Times: Real: $m:$s, User: $TIMEU, System: $TIMES");
|
|
|
2029 |
}
|
|
|
2030 |
#.
|
|
|
2031 |
# Make sure that any important exit code is passed to the user
|
|
|
2032 |
#
|
|
|
2033 |
Verbose ("ExitCode: $RESULT");
|
|
|
2034 |
exit $RESULT;
|
|
|
2035 |
}
|
|
|
2036 |
|
|
|
2037 |
########################################################################
|
|
|
2038 |
#
|
|
|
2039 |
# Main body of the script
|
|
|
2040 |
#
|
|
|
2041 |
# Process help and manual options
|
|
|
2042 |
# Done after all the setup to ensure that the PATH is correct
|
|
|
2043 |
# Done before bombout to give user a chance
|
|
|
2044 |
#
|
|
|
2045 |
help() if $opt_help;
|
|
|
2046 |
ErrorDoExit(); # Exit if any error in setup
|
|
|
2047 |
ErrorConfig( 'on_exit' => \&do_exit );
|
|
|
2048 |
|
|
|
2049 |
#
|
| 231 |
dpurdie |
2050 |
# Reset operational flags.
|
|
|
2051 |
# May have been used by setup
|
|
|
2052 |
#
|
|
|
2053 |
$opr_done = 0;
|
|
|
2054 |
$RESULT = 0;
|
|
|
2055 |
|
|
|
2056 |
#
|
| 227 |
dpurdie |
2057 |
# Process user commands
|
|
|
2058 |
#
|
| 263 |
dpurdie |
2059 |
my $cmd = shift @ARGV || help(1);
|
| 227 |
dpurdie |
2060 |
|
| 263 |
dpurdie |
2061 |
help(1) if ( $cmd =~ m/^help$/);
|
| 227 |
dpurdie |
2062 |
dump_vars(@ARGV) if ( $cmd =~ m/^var/ );
|
|
|
2063 |
print_version(@ARGV) if ( $cmd =~ m/^ver/ );
|
|
|
2064 |
|
|
|
2065 |
clobber if ( $cmd =~ m/^clobber$/ );
|
|
|
2066 |
build (@ARGV) if ( $cmd =~ m/^build$/ );
|
|
|
2067 |
|
|
|
2068 |
bmake_it ('NOTALL', @ARGV) if ( $cmd =~ m/^[x]*make$/ );
|
|
|
2069 |
bmake_it (@ARGV) if ( $cmd =~ m/^go$/ );
|
|
|
2070 |
bmake_it (dev_expand('debug', @ARGV) ) if ( $cmd =~ m/^debug$/ );
|
|
|
2071 |
bmake_it (dev_expand('prod', @ARGV) ) if ( $cmd =~ m/^prod$/ );
|
|
|
2072 |
bmake_it ("clean", @ARGV) if ( $cmd =~ m/^clean$/ );
|
|
|
2073 |
bmake_it ("rebuild", @ARGV) if ( $cmd =~ m/^rebuild$/ );
|
|
|
2074 |
bmake_it ('BUILD', @ARGV) if ( $cmd =~ m/^all$/ );
|
|
|
2075 |
bmake_it ($cmd, @ARGV ) if ( $cmd =~ m/^run_unit_tests/ );
|
|
|
2076 |
|
|
|
2077 |
install_pkg(@ARGV) if ( $cmd =~ m/^install$/ );
|
|
|
2078 |
create_dpkg(@ARGV) if ( $cmd =~ m/^create_dpkg$/ );
|
|
|
2079 |
|
|
|
2080 |
ebin (@ARGV) if ( $cmd =~ m/^ebin/ );
|
|
|
2081 |
etool (@ARGV) if ( $cmd =~ m/^etool/ );
|
|
|
2082 |
eprog (@ARGV) if ( $cmd =~ m/^eprog$/ );
|
|
|
2083 |
run_ant (@ARGV) if ( $cmd =~ m/^ant$/ );
|
|
|
2084 |
run_abt (@ARGV) if ( $cmd =~ m/^abt$/ );
|
|
|
2085 |
|
|
|
2086 |
etool ('cache_dpkg', @ARGV) if ( $cmd =~ m/^dpkg/ );
|
|
|
2087 |
etool ('gen_msprojects', @ARGV) if ( $cmd =~ m/^gen_msproject/ );
|
| 263 |
dpurdie |
2088 |
etool ('jats_ccrelease.pl', @ARGV) if ( $cmd =~ m/^cbuild/ );
|
|
|
2089 |
etool ('jats_ccrelease.pl', @ARGV) if ( $cmd =~ m/^release/ );
|
|
|
2090 |
etool ('jats_ccrelease.pl', '-extract' ,@ARGV) if ( $cmd =~ m/^extract/ );
|
| 227 |
dpurdie |
2091 |
etool ('jats_label', @ARGV) if ( $cmd =~ m/^label$/ );
|
|
|
2092 |
etool ('jats_sandbox', @ARGV) if ( $cmd =~ m/^sandbox$/ );
|
|
|
2093 |
|
|
|
2094 |
etool ($cmd, @ARGV) unless ($opr_done); # Pass to etool if not known
|
|
|
2095 |
|
|
|
2096 |
do_exit();
|
|
|
2097 |
#.
|
|
|
2098 |
|
|
|
2099 |
#-------------------------------------------------------------------------------
|
|
|
2100 |
# Documentation
|
|
|
2101 |
#
|
|
|
2102 |
|
|
|
2103 |
=pod
|
|
|
2104 |
|
|
|
2105 |
=head1 NAME
|
|
|
2106 |
|
|
|
2107 |
jats - JATS utility interface tool
|
|
|
2108 |
|
|
|
2109 |
=head1 SYNOPSIS
|
|
|
2110 |
|
| 277 |
dpurdie |
2111 |
Usage: jats [opts] command [cmd-options]
|
| 227 |
dpurdie |
2112 |
|
|
|
2113 |
Where opts:
|
| 261 |
dpurdie |
2114 |
-h, -h -h, -man=[n] - Help messages with increasing verbosity
|
| 227 |
dpurdie |
2115 |
-cd dir - Change to specified directory
|
|
|
2116 |
-b file - Use alternate build file
|
| 261 |
dpurdie |
2117 |
-verbose[=n] - Verbose operation
|
|
|
2118 |
-debug[=n] - Enable debug mode of JATS scripts
|
| 227 |
dpurdie |
2119 |
-here - Disable JATS auto locate of build.pl
|
|
|
2120 |
-locate - Locate build.pl file and change to directory
|
| 245 |
dpurdie |
2121 |
-locatepkg=pkg - Locate build.pl. Resolve multiple files via pkg
|
| 227 |
dpurdie |
2122 |
-locatefile=file - Locate specified file and change to directory
|
|
|
2123 |
-platform=[name] - Set GBE_PLATFORM to name (=+ to append)
|
|
|
2124 |
-buildfilter=[xxx] - Set GBE_BUILDFILTER to xxx (=+ to append)
|
|
|
2125 |
-abt=[xxx] - Set GBE_ABT to xxx (=+ to append)
|
|
|
2126 |
-java=version - Alters java version used (1.4, 1.5)
|
|
|
2127 |
-time - Time build and compile times
|
|
|
2128 |
-version=xxx - Use specified version of JATS
|
| 277 |
dpurdie |
2129 |
-[no]exportvars - Export sanitised JATS EnvVars (default)
|
| 227 |
dpurdie |
2130 |
|
|
|
2131 |
Where command is one of:
|
|
|
2132 |
build - Rebuild the sandbox and makefiles
|
|
|
2133 |
make - Make one or more components
|
|
|
2134 |
ant - Invoke an ant build
|
|
|
2135 |
abt [-java=xxx] - Invoke the auto build tool
|
|
|
2136 |
install - Install package into local_dpkg_archive
|
|
|
2137 |
help - Display help message
|
|
|
2138 |
vars - Display JATS related environment variables
|
|
|
2139 |
|
|
|
2140 |
create_dpkg - Install a package into main dpkg_archive
|
|
|
2141 |
label - Labelling functions
|
|
|
2142 |
release - Build a release from a clearcase label
|
|
|
2143 |
extract - Extract a release from a clearcase label
|
|
|
2144 |
dpkg_cache - Maintain a dpkg cache
|
|
|
2145 |
gen_msproject - Generate MSVC project files
|
|
|
2146 |
etool name - Run internal tool
|
|
|
2147 |
eprog name - Run external tool
|
|
|
2148 |
ebin name - Run JATS binary tool
|
|
|
2149 |
|
|
|
2150 |
Shortcut commands. Composites of basic commands
|
|
|
2151 |
all [opt] - Same as a "build" and "make all"
|
|
|
2152 |
go [opt] - Same as a "make all"
|
|
|
2153 |
debug [tgt] - Same as "make debug package_debug"
|
|
|
2154 |
prod [tgt] - Same as "make prod package_prod"
|
|
|
2155 |
clean - Same as "make clean"
|
|
|
2156 |
clobber - Same as "build clobber"
|
|
|
2157 |
* - Unknown commands are treated as arguments to etool
|
|
|
2158 |
|
|
|
2159 |
Where [cmd-options] are command specific.
|
|
|
2160 |
Try "jats command -help" for details
|
|
|
2161 |
|
|
|
2162 |
=head1 OPTIONS
|
|
|
2163 |
|
|
|
2164 |
=over 8
|
|
|
2165 |
|
|
|
2166 |
=item B<-help>
|
|
|
2167 |
|
|
|
2168 |
Print a brief help message and exits.
|
|
|
2169 |
|
|
|
2170 |
=item B<-help -help>
|
|
|
2171 |
|
|
|
2172 |
Print a detailed help message with an explanation for each option.
|
|
|
2173 |
|
| 261 |
dpurdie |
2174 |
=item B<-man[=n]>
|
| 227 |
dpurdie |
2175 |
|
|
|
2176 |
Prints the manual page and exits.
|
|
|
2177 |
|
| 261 |
dpurdie |
2178 |
If a numeric manual level is provide then it will be used to control the
|
|
|
2179 |
verbosity of help provided. This should be inthe range of 1 to 3.
|
|
|
2180 |
|
| 227 |
dpurdie |
2181 |
=item B<-b file> B<-buildfile file>
|
|
|
2182 |
|
|
|
2183 |
This option modifies the operation of the "build" command. The command will
|
|
|
2184 |
use the specified file instead of the normal build.pl file.
|
|
|
2185 |
|
|
|
2186 |
=item B<-cd dir> B<-changedir dir>
|
|
|
2187 |
|
|
|
2188 |
This option will change to specified directory before the command is invoked.
|
|
|
2189 |
|
| 261 |
dpurdie |
2190 |
=item B<--verbose[=n]>
|
| 227 |
dpurdie |
2191 |
|
|
|
2192 |
This option will increase the level of verbosity of the JATS command and command
|
| 261 |
dpurdie |
2193 |
invoked by the JATS shell.
|
| 227 |
dpurdie |
2194 |
|
| 261 |
dpurdie |
2195 |
If an argument is provided, then it will be used to set the level, otherwise the
|
|
|
2196 |
existing level will be incremented. This option may be specified multiple times.
|
| 227 |
dpurdie |
2197 |
|
| 261 |
dpurdie |
2198 |
=item B<-debug[=n]>
|
|
|
2199 |
|
| 227 |
dpurdie |
2200 |
This option will increase the level of debug output of the JATS command and command
|
| 261 |
dpurdie |
2201 |
invoked by the JATS shell.
|
| 227 |
dpurdie |
2202 |
|
| 261 |
dpurdie |
2203 |
If an argument is provided, then it will be used to set the level, otherwise the
|
|
|
2204 |
existing level will be incremented. This option may be specified multiple times.
|
|
|
2205 |
|
| 227 |
dpurdie |
2206 |
=item B<-here>
|
|
|
2207 |
|
|
|
2208 |
This option will disable the "autolocate" mechanism of the JATS shell script.
|
|
|
2209 |
|
|
|
2210 |
By default JATS will "hunt" for a suitable "build.pl" or "makefile.pl" before
|
|
|
2211 |
executing a build or a make command. JATS will look in the following directories
|
|
|
2212 |
for a suitable file. Under some conditions this mechanism is not useful.
|
|
|
2213 |
|
|
|
2214 |
By default JATS will hunt in the following directories: "." "jats" "build/
|
|
|
2215 |
jats" ".." "../.." and "../../..".
|
|
|
2216 |
|
|
|
2217 |
=item B<-locate>
|
|
|
2218 |
|
|
|
2219 |
This option will cause the JATS wrapper script to locate the build.pl file and
|
|
|
2220 |
then change to that directory. This allows users to locate the build root of
|
|
|
2221 |
a project and then issue other JATS commands.
|
|
|
2222 |
|
|
|
2223 |
If the B<-c> option is also specified then searching will start in the specified
|
|
|
2224 |
directory.
|
|
|
2225 |
|
|
|
2226 |
If an alternate build file is specified with the B<-b> option then that filename
|
|
|
2227 |
will be used in the location process.
|
|
|
2228 |
|
|
|
2229 |
This option implies a B<-here>. No further scanning will be done.
|
|
|
2230 |
|
|
|
2231 |
Exactly one build file must be located. If more than buildfile is located then
|
|
|
2232 |
the locations of the build files is displayed and JATS will terminate.
|
|
|
2233 |
|
| 245 |
dpurdie |
2234 |
|
|
|
2235 |
=item B<-locatepkg=packagename>
|
|
|
2236 |
|
|
|
2237 |
This option is similar to the B<-locate> option, but it allows the required
|
|
|
2238 |
build files to be located by ensuring that the required buildfile builds the
|
|
|
2239 |
specified package.
|
|
|
2240 |
|
|
|
2241 |
There are two forms in which the B<packagename> can be specified. It can be
|
|
|
2242 |
specified as a full package name and vesrion, or as a package name and the
|
|
|
2243 |
project suffix. ie: jats-api.1.0.0000.cr or jats-api.cr
|
|
|
2244 |
|
| 227 |
dpurdie |
2245 |
=item B<-locatefile=file>
|
|
|
2246 |
|
|
|
2247 |
This option is similar to the B<-locate> option, but it allows the name of the
|
|
|
2248 |
file to be located to be specified.
|
|
|
2249 |
|
|
|
2250 |
=item B<-platform=[name]>
|
|
|
2251 |
|
|
|
2252 |
This option will set the JATS specific environment variable GBE_PLATFORM to
|
|
|
2253 |
the specified name. The existing value of GBE_PLATFORM may be extended by
|
|
|
2254 |
using "=+".
|
|
|
2255 |
|
|
|
2256 |
In practice the GBE_PLATFORM variable is of little use. The same effect can be
|
|
|
2257 |
achieved directly with make targets or with GBE_BUILDFILTER.
|
|
|
2258 |
|
|
|
2259 |
=item B<-buildfilter=[xxx]>
|
|
|
2260 |
|
|
|
2261 |
This option will set the JATS specific environment variable GBE_BUILDFILTER to
|
|
|
2262 |
the specified name. The existing value of GBE_BUILDFILTER may be extended by
|
|
|
2263 |
using "=+".
|
|
|
2264 |
|
|
|
2265 |
This option may be used to limit the initial build, and subsequent "make" to a
|
|
|
2266 |
limited set of platforms.
|
|
|
2267 |
|
|
|
2268 |
=item B<-abt=[xxx]>
|
|
|
2269 |
|
|
|
2270 |
This option will set the JATS specific environment variable GBE_ABT to
|
|
|
2271 |
the specified name The existing value of GBE_ABT may be extended by
|
|
|
2272 |
using "=+"..
|
|
|
2273 |
|
|
|
2274 |
This option is used to pass arguments directly to some tools within the
|
|
|
2275 |
(ABT) Auto Build Tool framework, or to indicate that the build is being
|
|
|
2276 |
performed within the ABT framework.
|
|
|
2277 |
|
|
|
2278 |
=item B<-java=version>
|
|
|
2279 |
|
|
|
2280 |
This option will override the default java version used by the ant builds and
|
|
|
2281 |
passed to the underlying programs. The path to the Java SDK is determined from
|
|
|
2282 |
the environment using the version string replacing the '.' with '_'
|
|
|
2283 |
|
|
|
2284 |
eg: -java=1.5, will examine the environment for JAVA_HOME_1_5 and will set
|
|
|
2285 |
JAVA_HOME to that value. It will not setup the users PATH or classpath.
|
|
|
2286 |
|
|
|
2287 |
=item B<-time>
|
|
|
2288 |
|
|
|
2289 |
When this option is enabled the JATS script will report the runtime of the
|
|
|
2290 |
underlying, invoked, command.
|
|
|
2291 |
|
|
|
2292 |
=item B<-version=xxx>
|
|
|
2293 |
|
|
|
2294 |
When this option is invoked JATS will attempt to use the specified version to
|
|
|
2295 |
perform all processing. JATS will search the GBE_DPKG_LOCAL, GBE_DPKG_CACHE,
|
|
|
2296 |
GBE_DPKG, GBE_DPKG_STORE in order to locate the specified version of the package.
|
|
|
2297 |
|
|
|
2298 |
The entire command line will be passed to the JATS wrapper script within that
|
|
|
2299 |
version. This bypasses the jats.bat or jats.sh startup scripts.
|
|
|
2300 |
|
| 277 |
dpurdie |
2301 |
JATS will attempt to transfer the target version to the local cache in an
|
|
|
2302 |
attempt to improve performance.
|
| 227 |
dpurdie |
2303 |
|
| 277 |
dpurdie |
2304 |
=item B<-[no]exportvars>
|
| 227 |
dpurdie |
2305 |
|
| 277 |
dpurdie |
2306 |
The default operation is to export sanitised and calculated values to the
|
|
|
2307 |
programs running under JATS. The use of NoExportVars will prevent JATS from
|
|
|
2308 |
exporting modified EnvVars into the environment. This may be required by
|
|
|
2309 |
processes, such as the build daemons that need to pick up the current version of
|
|
|
2310 |
JATS on the fly and not have it fixed when the daemon is started.
|
| 227 |
dpurdie |
2311 |
|
|
|
2312 |
=back
|
|
|
2313 |
|
|
|
2314 |
=head1 ARGUMENTS
|
|
|
2315 |
|
|
|
2316 |
=head2 Basic Commands
|
|
|
2317 |
|
|
|
2318 |
The following commands are invoked directly by the JATS script to wrap the build
|
|
|
2319 |
tools in a controlled manner.
|
|
|
2320 |
|
|
|
2321 |
=over 8
|
|
|
2322 |
|
|
|
2323 |
=item B<build>
|
|
|
2324 |
|
|
|
2325 |
Build or rebuild the sandbox and makefiles.
|
|
|
2326 |
|
|
|
2327 |
This command must be used before the component can be "made" and when the
|
|
|
2328 |
contents of the "buildpl" file change. It is a common mistake to use the "build"
|
|
|
2329 |
command to much.
|
|
|
2330 |
|
|
|
2331 |
The script will hunt for a suitable build.pl file before running the build and
|
|
|
2332 |
make subcommands.
|
|
|
2333 |
|
|
|
2334 |
The build process has a large number of options. Use "JATS build help" to
|
|
|
2335 |
display the complete list.
|
|
|
2336 |
|
|
|
2337 |
=item B<make>
|
|
|
2338 |
|
|
|
2339 |
Make one or more components
|
|
|
2340 |
|
|
|
2341 |
This command will invoke a suitable "make" program on the makefile found in
|
|
|
2342 |
the current directory. This makefile should have been generated by JATS.
|
|
|
2343 |
|
|
|
2344 |
The make process has a large number of options. Use "JATS make help" to
|
|
|
2345 |
display the complete list.
|
|
|
2346 |
|
|
|
2347 |
=item B<ant>
|
|
|
2348 |
|
|
|
2349 |
This command will use ANT to build a component. JATS will determine the
|
|
|
2350 |
build.xml file to use with the following algorithm.
|
|
|
2351 |
|
|
|
2352 |
If the files called <Project>depends.xml and <Project>.xml exist then JATS
|
|
|
2353 |
will create an 'auto.xml' from the depends file, if one does not already
|
|
|
2354 |
exist or is older than the depends.xml file and then use the <Project>.xml
|
|
|
2355 |
file as the ant build file.
|
|
|
2356 |
|
|
|
2357 |
Otherwise ant is invoked and it will expect a build.xml file.
|
|
|
2358 |
|
|
|
2359 |
If multiple <Project>depends.xml and <Project>.xml file pairs are found the
|
|
|
2360 |
command will fail. This can be resolved through the use of the -buildfile=name
|
|
|
2361 |
option.
|
|
|
2362 |
|
|
|
2363 |
Ant is invoked with the version of Java specified with the -Java=x.x option.
|
|
|
2364 |
|
|
|
2365 |
=item B<abt>
|
|
|
2366 |
|
|
|
2367 |
This command is used to invoke the Auto Build Tool. It will invoke ANT on the
|
|
|
2368 |
build.xml file in the current directory in such manner as to not affect the
|
| 239 |
dpurdie |
2369 |
environment of the programs running under ANT.
|
| 227 |
dpurdie |
2370 |
|
| 245 |
dpurdie |
2371 |
The remained of the command line is passed to the ABT, with the exception of
|
| 239 |
dpurdie |
2372 |
the options:
|
|
|
2373 |
|
|
|
2374 |
=over 8
|
|
|
2375 |
|
|
|
2376 |
=item * -java=x.x. This is used to control the version of Java used by the
|
| 227 |
dpurdie |
2377 |
ABT. The default is 1.5.
|
|
|
2378 |
|
| 239 |
dpurdie |
2379 |
=item * -buildfile=name. This is used to provide a different build file to ant.
|
|
|
2380 |
The default build file is 'build.xml'.
|
|
|
2381 |
|
|
|
2382 |
=back
|
|
|
2383 |
|
| 227 |
dpurdie |
2384 |
=item B<install>
|
|
|
2385 |
|
|
|
2386 |
This command will install a generated "package" into the local_dpkg_archive
|
|
|
2387 |
directory. This allows a group of packages to be tested before being published
|
|
|
2388 |
into the global dpkg_archive.
|
|
|
2389 |
|
|
|
2390 |
NOTE. This command is no longer needed. The "build" process will place a
|
|
|
2391 |
shortcut in the local_dpkg_archive to a components "pkg" directory. Other
|
|
|
2392 |
components will utilize this shortcut directly and pickup the package without
|
|
|
2393 |
the user needing to "install" the package - a step that can be forgotten.
|
|
|
2394 |
|
|
|
2395 |
=item B<help>
|
|
|
2396 |
|
|
|
2397 |
Display the basic help message.
|
|
|
2398 |
|
|
|
2399 |
=item B<vars [-v]>
|
|
|
2400 |
|
|
|
2401 |
This command will display all the JATS related environment variables in a
|
|
|
2402 |
readable form.
|
|
|
2403 |
|
|
|
2404 |
Additional information will be displayed if an argument of "-v" is provided.
|
|
|
2405 |
|
|
|
2406 |
=back
|
|
|
2407 |
|
|
|
2408 |
=head2 Extended Commands
|
|
|
2409 |
|
|
|
2410 |
The following commands support the build environment. They are supplemental to
|
|
|
2411 |
the build environment. They are implemented as extensions to the basic JATS
|
|
|
2412 |
command scripts.
|
|
|
2413 |
|
|
|
2414 |
=over 8
|
|
|
2415 |
|
|
|
2416 |
=item B<create_dpkg>
|
|
|
2417 |
|
|
|
2418 |
This command will install a generated package into main dpkg_archive. This
|
|
|
2419 |
command should not be used directly by a user as it does not ensure that package
|
|
|
2420 |
has been created in a repeatable manner - use "jats release".
|
|
|
2421 |
|
|
|
2422 |
=item B<label>
|
|
|
2423 |
|
|
|
2424 |
This command provides a number of useful labelling mechanisms to assist in the
|
|
|
2425 |
labeling of source code.
|
|
|
2426 |
|
|
|
2427 |
=item B<release>, B<cbuild>
|
|
|
2428 |
|
|
|
2429 |
This command allows a package to be built and released, given a Clearcase label.
|
|
|
2430 |
This is the desired release mechanism.
|
|
|
2431 |
|
|
|
2432 |
The command has two main uses:
|
|
|
2433 |
|
|
|
2434 |
=over 8
|
|
|
2435 |
|
|
|
2436 |
=item 1
|
|
|
2437 |
|
|
|
2438 |
Build a package for release. The process will ensure that the build is
|
|
|
2439 |
controlled and repeatable.
|
|
|
2440 |
|
|
|
2441 |
=item 2
|
|
|
2442 |
|
|
|
2443 |
Rebuild a package for test or debugging purposes.
|
|
|
2444 |
|
|
|
2445 |
=back
|
|
|
2446 |
|
|
|
2447 |
=item B<extract>
|
|
|
2448 |
|
|
|
2449 |
This is the same as "release -extract"
|
|
|
2450 |
|
|
|
2451 |
|
|
|
2452 |
=item B<dpkg_cache>
|
|
|
2453 |
|
|
|
2454 |
This utility provides a number of commands to maintain the local cache of
|
| 245 |
dpurdie |
2455 |
dpkg_archive.
|
| 227 |
dpurdie |
2456 |
|
|
|
2457 |
=item B<gen_msproject>
|
|
|
2458 |
|
|
|
2459 |
This utility will generate a set of Microsoft Studio (Version 6) project and
|
|
|
2460 |
workspace files to encapsulate the JATS build. The resultant project allows VS
|
|
|
2461 |
to be used as an editor, source browser, debugger and build tool. JATS is
|
|
|
2462 |
still used to perform the build.
|
|
|
2463 |
|
|
|
2464 |
=item B<etool name>
|
|
|
2465 |
|
|
|
2466 |
This command allows any JATS extension program to be run. The programs will by
|
|
|
2467 |
found in the JATS TOOLS directory.
|
|
|
2468 |
|
|
|
2469 |
=item B<eprog name>
|
|
|
2470 |
|
|
|
2471 |
This command allows any JATS extension program to be run.
|
|
|
2472 |
If the program end in .pl, then it will be run within a perl interpreter.
|
|
|
2473 |
If the program end in .jar, then it will be run under a java interpreter.
|
|
|
2474 |
|
|
|
2475 |
=item B<ebin name>
|
|
|
2476 |
|
|
|
2477 |
This command allows any JATS support program to be run. The programs will by
|
|
|
2478 |
found in the JATS BIN directory for the current platform. This command allows
|
|
|
2479 |
a user script to access many of the machine independent utilities in a simple
|
|
|
2480 |
manner.
|
|
|
2481 |
|
|
|
2482 |
Example: "JATS ebin ls" - will provide a "real" ls on all platforms.
|
|
|
2483 |
|
|
|
2484 |
Example: "JATS ebin sh" - will start up the shell used by make.
|
|
|
2485 |
|
|
|
2486 |
=back
|
|
|
2487 |
|
|
|
2488 |
=head2 Command Shortcuts
|
|
|
2489 |
|
|
|
2490 |
The following commands are user shortcuts to the basic commands. The are basic
|
|
|
2491 |
commands run in sequence.
|
|
|
2492 |
|
|
|
2493 |
=over 8
|
|
|
2494 |
|
|
|
2495 |
=item B<all [make_opts]>
|
|
|
2496 |
|
|
|
2497 |
This command is the same as running the command "build" and "make all".
|
|
|
2498 |
It will build a component with a single command.
|
|
|
2499 |
|
|
|
2500 |
If "make_opts" is not present then "make all" is used.
|
|
|
2501 |
|
|
|
2502 |
If "make_opts" is present then they are passed to the "make" command. In this
|
|
|
2503 |
manner is it possible to build a WIN32 component of package with a single
|
|
|
2504 |
command.
|
|
|
2505 |
|
|
|
2506 |
=item B<go [make_opts]>
|
|
|
2507 |
|
|
|
2508 |
This command is similar to the "all" shortcut, but it does not "build" the
|
|
|
2509 |
sandbox. It may be used where the sandbox has already been prepared.
|
|
|
2510 |
|
|
|
2511 |
=item B<debug [target]>
|
|
|
2512 |
|
|
|
2513 |
This command is the same as running "make debug package_debug". It will make and
|
|
|
2514 |
package all the debug components of a sandbox.
|
|
|
2515 |
|
|
|
2516 |
If any additional arguments are provided to the B<dev> command then they will be
|
|
|
2517 |
treated as make targets and the commands will be expanded to make and package
|
|
|
2518 |
the specified debug versions of the names platforms. Make options cannot be
|
|
|
2519 |
passed in this manner.
|
|
|
2520 |
|
|
|
2521 |
Example: "JATS dev GAK" will create and package the debug parts for the
|
|
|
2522 |
GAK_MOS68K and GAK_MOSCF.
|
|
|
2523 |
|
|
|
2524 |
=item B<prod [target]>
|
|
|
2525 |
|
|
|
2526 |
This command is the same as running "make prod package_prod". It will make and
|
|
|
2527 |
package all the debug components of a sandbox.
|
|
|
2528 |
|
|
|
2529 |
If any additional arguments are provided to the B<prod> command then they will be
|
|
|
2530 |
treated as make targets and the commands will be expanded to make and package
|
|
|
2531 |
the specified debug versions of the names platforms. Make options cannot be
|
|
|
2532 |
passed in this manner.
|
|
|
2533 |
|
|
|
2534 |
Example: "JATS prod GAK" will create and package the production parts for the
|
|
|
2535 |
GAK_MOS68K and GAK_MOSCF.
|
|
|
2536 |
|
|
|
2537 |
=item B<clean>
|
|
|
2538 |
|
|
|
2539 |
This is the same as "make clean".
|
|
|
2540 |
|
|
|
2541 |
=item B<clobber>
|
|
|
2542 |
|
|
|
2543 |
This is the same as "build clobber"
|
|
|
2544 |
|
|
|
2545 |
=item B<else>
|
|
|
2546 |
|
|
|
2547 |
Commands that are not known to the JATS wrapper script are passed to etool.
|
|
|
2548 |
|
|
|
2549 |
ie: "JATS xxxx" is is the same as "JATS etool xxxx".
|
|
|
2550 |
|
|
|
2551 |
=back
|
|
|
2552 |
|
|
|
2553 |
=head1 DESCRIPTION
|
|
|
2554 |
|
|
|
2555 |
JATS is a wrapper script. It provides:
|
|
|
2556 |
|
|
|
2557 |
=over 8
|
|
|
2558 |
|
|
|
2559 |
=item *
|
|
|
2560 |
|
|
|
2561 |
A controlled and satirized environment to all the build tools.
|
|
|
2562 |
|
|
|
2563 |
=item *
|
|
|
2564 |
|
|
|
2565 |
The same command interface on all supported machines: Windows, Solaris and
|
|
|
2566 |
Linux.
|
|
|
2567 |
|
|
|
2568 |
=item *
|
|
|
2569 |
|
|
|
2570 |
Provides a framework for extending the build environment toolset.
|
|
|
2571 |
|
|
|
2572 |
=back
|
|
|
2573 |
|
|
|
2574 |
=head1 Installation of the startup script
|
|
|
2575 |
|
|
|
2576 |
The JATS wrapper script is invoked via a machine specific script. This is B<JATS.
|
|
|
2577 |
BAT> under Windows and B<JATS.SH> under Unix platforms. The startup script
|
|
|
2578 |
contains sufficient information to startup the main, and common, JATS
|
|
|
2579 |
program. The script specifies the environment on the machine and should not
|
|
|
2580 |
affect the target build environment. It also isolates the JATS version changes
|
|
|
2581 |
from the user.
|
|
|
2582 |
|
|
|
2583 |
This script is intended to be user configured. It should be copied into the
|
|
|
2584 |
users path and modified. It is intended that the script will not change from
|
|
|
2585 |
version to version of JATS.
|
|
|
2586 |
|
|
|
2587 |
=head2 Environment variables
|
|
|
2588 |
|
| 255 |
dpurdie |
2589 |
Environmant varibales that specify a path may be set to '-', or 'none' in order
|
|
|
2590 |
to force an undefined path.
|
|
|
2591 |
|
| 227 |
dpurdie |
2592 |
=over 8
|
|
|
2593 |
|
|
|
2594 |
=item GBE_MACHTYPE
|
|
|
2595 |
|
|
|
2596 |
This specifies the machine that the script is running on. This is fixed within
|
|
|
2597 |
the startup script.
|
|
|
2598 |
|
| 273 |
dpurdie |
2599 |
=item GBE_HOSTMACH
|
|
|
2600 |
|
|
|
2601 |
This is a copy of GBE_MACHTYPE.
|
|
|
2602 |
Unlike GBE_MACHTYPE, this copy is not modified by makefiles.
|
|
|
2603 |
|
| 227 |
dpurdie |
2604 |
=item GBE_PERL
|
|
|
2605 |
|
|
|
2606 |
This specifies the full path the to B<ActiveState> perl binary.
|
|
|
2607 |
|
|
|
2608 |
=item GBE_CORE
|
|
|
2609 |
|
|
|
2610 |
This specifies the path the to B<JATS> installation.
|
|
|
2611 |
|
|
|
2612 |
=item GBE_CACHE_JATS
|
|
|
2613 |
|
|
|
2614 |
When set to a non zero value will force JATS to transfer a working copy to the
|
|
|
2615 |
local dpkg_archive. This will speed up the build process because the utilities
|
|
|
2616 |
will be run from a local drive; not a network drive.
|
|
|
2617 |
|
|
|
2618 |
This will only operate if JATS is run from dpkg_archive.
|
|
|
2619 |
|
|
|
2620 |
=item GBE_DPKG_STORE (optional)
|
|
|
2621 |
|
|
|
2622 |
This is the global read-only archive store. It will only be used to source
|
|
|
2623 |
packages after all other archive stores have been examined. The GBE_DPKG_STORE
|
|
|
2624 |
is intended to provide a read-only or remote repository within a global
|
|
|
2625 |
environment.
|
|
|
2626 |
|
|
|
2627 |
=item GBE_DPKG
|
|
|
2628 |
|
|
|
2629 |
This is the official archive. Some tools will publish packages directly to this
|
|
|
2630 |
archive.
|
|
|
2631 |
|
|
|
2632 |
=item GBE_DPKG_CACHE (optional)
|
|
|
2633 |
|
|
|
2634 |
This the path to a local package archive cache. This is used to speed access to
|
|
|
2635 |
main repository. The cache should be on the users local machine and not a network
|
|
|
2636 |
drive.
|
|
|
2637 |
|
|
|
2638 |
=item GBE_DPKG_LOCAL (optional)
|
|
|
2639 |
|
|
|
2640 |
This the path to a group wide local package archive. This may be used to store
|
|
|
2641 |
non-official packages that are under test or development.
|
|
|
2642 |
|
|
|
2643 |
=item GBE_DPKG_SBOX (optional)
|
|
|
2644 |
|
|
|
2645 |
This the path to a sandbox specific package archive. This may be used to store
|
|
|
2646 |
non-official packages that are under test or development within the current sandbox.
|
|
|
2647 |
|
|
|
2648 |
The archive is located by searching from the current directory to the root of
|
|
|
2649 |
the filesystem for a directory called 'sandbox_dpkg_archive'.
|
|
|
2650 |
|
|
|
2651 |
It is intended that a group of packages that are being developed in the same
|
|
|
2652 |
sandbox will share the same sandbox_dpkg_archive.
|
|
|
2653 |
|
|
|
2654 |
Jats will ignore the version number when dealing with packages in GBE_DPKG_SBOX.
|
|
|
2655 |
This is done to simplify the publishing and consuming of packages in the sandbox.
|
|
|
2656 |
|
|
|
2657 |
This should not be set by a user. It will be calculated by JATS and passed to
|
| 245 |
dpurdie |
2658 |
JATS tools and utilities.
|
| 227 |
dpurdie |
2659 |
|
|
|
2660 |
=item GBE_SANDBOX (optional)
|
|
|
2661 |
|
|
|
2662 |
This the path to a sandbox base directory. It is intended that a group of
|
|
|
2663 |
packages that are being developed in the same sandbox will share the same
|
|
|
2664 |
sandbox_dpkg_archive.
|
|
|
2665 |
|
|
|
2666 |
This should not be set by a user. It will be calculated by JATS and passed to
|
| 245 |
dpurdie |
2667 |
JATS tools and utilities.
|
| 227 |
dpurdie |
2668 |
|
|
|
2669 |
=item GBE_DPLY (optional)
|
|
|
2670 |
|
|
|
2671 |
This the path to the deployment archive.
|
|
|
2672 |
This archive is NOT used when searching for packages, but it will be used when
|
|
|
2673 |
publishing special deployment package. This is not the norm.
|
|
|
2674 |
|
|
|
2675 |
This variable may be set on a per-project basis.
|
|
|
2676 |
|
|
|
2677 |
=item GBE_PLATFORM (deprecated)
|
|
|
2678 |
|
|
|
2679 |
This specifies the names of platforms that will be built and made. This should
|
|
|
2680 |
be empty. Use B<GBE_BUILDFILTER> to provide better control.
|
|
|
2681 |
|
|
|
2682 |
=item GBE_BUILDFILTER (desirable)
|
|
|
2683 |
|
|
|
2684 |
This is a filter string that specifies which platforms to create makefiles
|
|
|
2685 |
for. This variable is used to prevent JATS from creating Solaris and Linux
|
|
|
2686 |
targets on a Windows machine and visa-versa.
|
|
|
2687 |
|
|
|
2688 |
=item GBE_JATS_VERSION (optional)
|
|
|
2689 |
|
|
|
2690 |
Specifies the version of JATS that the user will use. This is the same as
|
|
|
2691 |
specifying the -version=xx.xx.xx option on the command line, but because it is
|
|
|
2692 |
in the environment the required version will be used by all invocations of JATS.
|
|
|
2693 |
|
|
|
2694 |
=item GBE_ABT (optional)
|
|
|
2695 |
|
|
|
2696 |
Used by the Auto Build Tool to indicate that the build is being performed by the
|
|
|
2697 |
ABT. When set the build environment will be modified to suite the ABT. Some
|
|
|
2698 |
operations may be relaxed.
|
|
|
2699 |
|
|
|
2700 |
=item GBE_VIEWBASE (optional)
|
|
|
2701 |
|
|
|
2702 |
Used by the 'release' utility to provide a user configurable base directory for
|
|
|
2703 |
the creation of static views.
|
|
|
2704 |
|
|
|
2705 |
=item GBE_RM_LOCATION (optional)
|
|
|
2706 |
|
|
|
2707 |
Used by tools that interface to Release Manager: primarily the (ABT) Auto Build Tools.
|
| 245 |
dpurdie |
2708 |
Specifies the location of the Release Manager Database. This is a database url
|
| 227 |
dpurdie |
2709 |
of the form jdbc:subprotocol:subname as used by java.sql.DriverManager.getConnection()
|
|
|
2710 |
|
|
|
2711 |
Example: jdbc:oracle:thin:@auperaora03:1521:RELEASEM
|
|
|
2712 |
|
|
|
2713 |
=item GBE_RM_USERNAME (optional)
|
|
|
2714 |
|
|
|
2715 |
Used by tools that interface to Release Manager: primarily the (ABT) Auto Build Tools.
|
|
|
2716 |
Specifies a USERNAME with access to the Release Manager Database.
|
|
|
2717 |
|
|
|
2718 |
=item GBE_RM_PASSWORD (optional)
|
|
|
2719 |
|
|
|
2720 |
Used by tools that interface to Release Manager: primarily the (ABT) Auto Build Tools.
|
|
|
2721 |
Specifies a PASSWORD to be used in conjunction with GBE_RM_USERNAME to access
|
|
|
2722 |
the Release Manager Database.
|
|
|
2723 |
|
|
|
2724 |
=item GBE_RM_URL (optional)
|
|
|
2725 |
|
|
|
2726 |
Used by tools that interface to Release Manager: primarily the (ABT) Auto Build Tools.
|
|
|
2727 |
Specifies the base URL of RElease Manager
|
|
|
2728 |
|
|
|
2729 |
=item GBE_DM_LOCATION (optional)
|
|
|
2730 |
|
|
|
2731 |
Similar to GBE_RM_LOCATION, but is used to access the Deployment Manager Database.
|
|
|
2732 |
If GBE_DM_LOCATION is not provided, then GBE_RM_LOCATION will be used.
|
|
|
2733 |
|
|
|
2734 |
=item GBE_DM_USERNAME (optional)
|
|
|
2735 |
|
|
|
2736 |
Similar to GBE_RM_USERNAME, but is used to access the Deployment Manager Database.
|
|
|
2737 |
|
|
|
2738 |
=item GBE_DM_PASSWORD (optional)
|
|
|
2739 |
|
|
|
2740 |
Similar to GBE_RM_PASSWORD, but is used to access the Deployment Manager Database.
|
|
|
2741 |
|
|
|
2742 |
=item GBE_DM_URL (optional)
|
|
|
2743 |
|
|
|
2744 |
Similar to GBE_DM_URL, but is used to access the Deployment Manager Database.
|
|
|
2745 |
|
| 275 |
dpurdie |
2746 |
=item GBE_MAKE_TYPE (internal)
|
|
|
2747 |
|
|
|
2748 |
This EnvVar is set when a Makefile is being procssed by 'make'. The value
|
|
|
2749 |
indicates the type of the build. It will be either P(Production), D(debug)
|
|
|
2750 |
or C(Common).
|
|
|
2751 |
|
|
|
2752 |
=item GBE_MAKE_TARGET (internal)
|
|
|
2753 |
|
|
|
2754 |
This EnvVar is set when a Makefile is being procssed by 'make'. The value
|
|
|
2755 |
is set current target platform name.
|
|
|
2756 |
|
|
|
2757 |
=item GBE_MAKE_CFG (internal)
|
|
|
2758 |
|
|
|
2759 |
This EnvVar is set when a Makefile is being procssed by 'make'. The value
|
| 285 |
dpurdie |
2760 |
is set to the path of the parsed makefile.pl data gathered when the makefile
|
| 275 |
dpurdie |
2761 |
was created.
|
|
|
2762 |
|
|
|
2763 |
=item GBE_MAKE_CMD (internal)
|
|
|
2764 |
|
|
|
2765 |
This EnvVar is set when a Makefile is being procssed by 'make'. The value
|
|
|
2766 |
is set current make command being processed.
|
|
|
2767 |
|
| 279 |
dpurdie |
2768 |
=item $GBE_HOSTNAME
|
|
|
2769 |
|
|
|
2770 |
This EnvVar is the name of the current host. It is available to be used within
|
|
|
2771 |
scripts that need to stamp build files.
|
|
|
2772 |
|
| 227 |
dpurdie |
2773 |
=back
|
|
|
2774 |
|
|
|
2775 |
=head1 dpkg_archive
|
|
|
2776 |
|
|
|
2777 |
B<dpkg_archive> is the common package repository. This is on a shared network drive
|
|
|
2778 |
and as such affects the build speed. JATS supports three mechanisms to supplement
|
|
|
2779 |
dpkg_archive, as described below. The archive search order is:
|
|
|
2780 |
|
|
|
2781 |
=over
|
|
|
2782 |
|
|
|
2783 |
=item GBE_DPKG_LOCAL (User local store)
|
|
|
2784 |
|
|
|
2785 |
=item GBE_DPKG_CACHE (Machine local cache)
|
|
|
2786 |
|
|
|
2787 |
=item GBE_DPKG (Site repository)
|
|
|
2788 |
|
|
|
2789 |
=item GBE_DPKG_STORE (Global repository)
|
|
|
2790 |
|
|
|
2791 |
=back
|
|
|
2792 |
|
|
|
2793 |
=head2 local dpkg_archive
|
|
|
2794 |
|
|
|
2795 |
JATS supports a package archive that is local to a project or suite of build
|
|
|
2796 |
sandboxes. This is the archive used by the B<install> command.
|
|
|
2797 |
|
|
|
2798 |
The user does not have to do anything to access this archive. The archive is
|
|
|
2799 |
located by the JATS wrapper script by scanning up the directory tree for a
|
|
|
2800 |
directory called "local_dpkg_archive". If it is found then it is used as the
|
|
|
2801 |
preferred source for locating archives. This allows a component to be tested
|
|
|
2802 |
with a "local" or "fixed" version of another package, before an official
|
|
|
2803 |
release is made.
|
|
|
2804 |
|
|
|
2805 |
A local archive may be shared by members of a team by setting the environment
|
|
|
2806 |
variable B<GBE_DPKG_LOCAL> to the location of a shared drive.
|
|
|
2807 |
|
|
|
2808 |
=head2 dpkg_archive cache
|
|
|
2809 |
|
|
|
2810 |
JATS supports a package caching mechanism to reduce network utilization. If
|
|
|
2811 |
the user specified B<GBE_DPKG_CACHE> exists then that archive is treated as a
|
|
|
2812 |
cache archive. The various JATS tools work together to maintain the cache.
|
|
|
2813 |
|
|
|
2814 |
This cache must be setup by the user.
|
|
|
2815 |
|
|
|
2816 |
=head2 dpkg_archive store
|
|
|
2817 |
|
|
|
2818 |
JATS supports a global, read-only, package distribution mechanism. If
|
|
|
2819 |
the user specified B<GBE_DPKG_STORE> exists then that archive is treated as a
|
|
|
2820 |
global store. The store archive will be searched after all other archives.
|
|
|
2821 |
|
|
|
2822 |
A global store may be used by members of a global team, in a situation in
|
|
|
2823 |
which the store is rsync'ed from a central repository.
|
|
|
2824 |
|
|
|
2825 |
=head1 EXAMPLES
|
|
|
2826 |
|
|
|
2827 |
=over 8
|
|
|
2828 |
|
|
|
2829 |
=item JATS build
|
|
|
2830 |
|
|
|
2831 |
This will prime the sandbox ready for "make". The command will locate the
|
|
|
2832 |
build.pl file and process it. This will locate all the external packages and
|
|
|
2833 |
generate the required makefiles.
|
|
|
2834 |
|
|
|
2835 |
=item JATS make
|
|
|
2836 |
|
|
|
2837 |
This will run the GNU make program over the makefiles generated by the "build"
|
|
|
2838 |
command. This may be executed in a subdirectory in order to limit the targets
|
|
|
2839 |
that are "made".
|
|
|
2840 |
|
|
|
2841 |
B<NOTE:> Do not run "make" without using the JATS wrapper. It will not perform
|
|
|
2842 |
as expected as the environment will not have been set up correctly.
|
|
|
2843 |
|
|
|
2844 |
=back
|
|
|
2845 |
|
|
|
2846 |
=cut
|
|
|
2847 |
|