Subversion Repositories DevTools

Rev

Rev 5710 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
392 dpurdie 1 
#! perl
2 
########################################################################
6177 dpurdie 3 
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
392 dpurdie 4 
#
5 
# Module name   : jats.sh
6 
# Module type   : Makefile system
7 
# Compiler(s)   : n/a
8 
# Environment(s): jats
9 
#
10 
# Description   : Walk compete dependency tree for a given package version
11 
#                 Generate a build order
12 
#                 Generate build directives
13 
#
14 
# Usage:
15 
#
16 
# Version   Who      Date        Description
17 
#
18 
#......................................................................#
19 
 
20 
require 5.006_001;
21 
use strict;
22 
use warnings;
23 
use JatsError;
24 
use JatsSystem;
25 
use Getopt::Long;
26 
use Pod::Usage;                             # required for help support
27 
use JatsRmApi;
28 
 
29 
use DBI;
30 
 
31 
my $VERSION = "1.2.3";                      # Update this
32 
my $opt_verbose = 1;
33 
my $opt_help = 0;
34 
my $opt_manual;
35 
my $opt_rtag_id = 2641;                     #  NZS
36 
my $opt_no_ver = 0;
37 
my $RM_DB;
38 
 
39 
#
40 
#   Package information
41 
#
42 
my %Package;
43 
my @StrayPackages;
44 
 
45 
#-------------------------------------------------------------------------------
46 
# Function        : Main Entry
47 
#
48 
# Description     :
49 
#
50 
# Inputs          :
51 
#
52 
# Returns         :
53 
#
54 
my $result = GetOptions (
55 
                "help+"         => \$opt_help,          # flag, multiple use allowed
56 
                "manual"        => \$opt_manual,        # flag
57 
                "verbose+"      => \$opt_verbose,       # flag
58 
                );
59 
 
60 
#
61 
#   Process help and manual options
62 
#
63 
pod2usage(-verbose => 0, -message => "Version: $VERSION")  if ($opt_help == 1  || ! $result);
64 
pod2usage(-verbose => 1)  if ($opt_help == 2 );
65 
pod2usage(-verbose => 2)  if ($opt_manual || ($opt_help > 2));
66 
 
67 
ErrorConfig( 'name'    =>'PLAY17' );
68 
 
69 
#
70 
#   Determine root package
71 
#
72 
unless ( $ARGV[0] && $ARGV[1] )
73 
{
74 
    print "Specify a package as 'name' 'version'\n";
75 
    exit;
76 
}
77 
my $pv_id = getPkgDetailsByName($ARGV[0], $ARGV[1]);
78 
GetDepends ( $pv_id, $ARGV[0], $ARGV[1] );
79 
#getPkgDetailsByRTAG_ID($opt_rtag_id);
80 
LocateStrays();
81 
BuildOrder();
82 
#DebugDumpData ("Package", \%Package );
83 
 
84 
exit;
85 
 
86 
 
87 
sub getPkgDetailsByName
88 
{
89 
    my ($pname, $pver) = @_;
90 
    my $pv_id;
91 
    my (@row);
92 
 
93 
    # if we are not or cannot connect then return 0 as we have not found anything
94 
    connectRM( \$RM_DB);
95 
 
96 
    # First get details for a given package version
97 
 
98 
    my $m_sqlstr = "SELECT pv.PV_ID, pkg.PKG_NAME, pv.PKG_VERSION" .
99 
                    " FROM PACKAGE_VERSIONS pv, PACKAGES pkg" .
100 
                    " WHERE pkg.PKG_NAME = \'$pname\' AND pv.PKG_VERSION = \'$pver\' AND pv.PKG_ID = pkg.PKG_ID";
101 
    my $sth = $RM_DB->prepare($m_sqlstr);
102 
    if ( defined($sth) )
103 
    {
104 
        if ( $sth->execute( ) )
105 
        {
106 
            if ( $sth->rows )
107 
            {
108 
                while ( @row = $sth->fetchrow_array )
109 
                {
110 
                    $pv_id = $row[0];
111 
                    my $name = $row[1];
112 
                    my $ver = $row[2];
113 
                    Verbose( "PV_ID= $pv_id");
114 
                }
115 
            }
116 
            $sth->finish();
117 
        }
118 
    }
119 
    else
120 
    {
121 
        Error("Prepare failure" );
122 
    }
123 
    return $pv_id;
124 
}
125 
 
126 
 
127 
 
128 
sub getPkgDetailsByRTAG_ID
129 
{
130 
    my ($RTAG_ID) = @_;
131 
    my $foundDetails = 0;
132 
    my (@row);
133 
 
134 
    # if we are not or cannot connect then return 0 as we have not found anything
135 
    connectRM( \$RM_DB);
136 
 
137 
    # First get details from pv_id
138 
 
139 
    my $m_sqlstr = "SELECT pv.PV_ID, pkg.PKG_NAME, pv.PKG_VERSION, pv.PKG_LABEL, pv.SRC_PATH, pv.BUILD_TYPE, pv.IS_DEPLOYABLE, rc.BASE_VIEW_ID" .
140 
                    " FROM RELEASE_CONTENT rc, PACKAGE_VERSIONS pv, PACKAGES pkg" .
141 
                    " WHERE rc.RTAG_ID = $RTAG_ID AND rc.PV_ID = pv.PV_ID AND pv.PKG_ID = pkg.PKG_ID";
142 
    my $sth = $RM_DB->prepare($m_sqlstr);
143 
    if ( defined($sth) )
144 
    {
145 
        if ( $sth->execute( ) )
146 
        {
147 
            if ( $sth->rows )
148 
            {
149 
                while ( @row = $sth->fetchrow_array )
150 
                {
151 
                    my $pv_id = $row[0];
152 
                    my $name = $row[1];
153 
                    my $ver = $row[2];
154 
                    my $label = $row[3] || '';
155 
                    my $path = $row[4] || '';
156 
                    my $deployable = $row[6];
157 
                    my $base_id = $row[7] || '';
158 
 
159 
                    if ($opt_no_ver)
160 
                    {
161 
                        push @{$Package{$name}{'xxx'}{ver_list}}, $ver;
162 
                        $ver = 'xxx';
163 
                    }
164 
 
165 
                    #
166 
                    #   Construct archive path
167 
                    #
168 
                    my $dpkg;
169 
                    foreach my $var ( 'GBE_DPKG', 'GBE_DPLY' )
170 
                    {
171 
                        my $pkg_dir="$ENV{$var}/${name}/${ver}";
172 
                        if ( -d $pkg_dir )
173 
                        {
174 
                            $dpkg = $pkg_dir;
175 
                            last;
176 
                        }
177 
                    }
178 
 
179 
                    $path =~ tr~\\/~/~s;
180 
#print "$row[5] --";
181 
#printf ( "%40s %15s %50s %s\n",  $name, $ver, $label, $path);
182 
#printf ( "copy e:\\%s\\%s .\n",  $name, $ver, $label, $path);
183 
#print "$name $ver\n";
184 
#print "$name $ver, $dpkg\n";
185 
                    $Package{$name}{$ver}{done} = 1;
186 
                    $Package{$name}{$ver}{base} = 1;
187 
                    $Package{$name}{$ver}{base_id} = $base_id;
188 
                    $Package{$name}{$ver}{deployable} = 1 if ($deployable);
189 
                    $Package{$name}{$ver}{dpkg} = $dpkg if ($dpkg);
190 
                    $Package{$name}{$ver}{label} = $label;
191 
                    $Package{$name}{$ver}{path} = $path;
192 
 
193 
                    GetDepends( $pv_id, $name, $ver );
194 
                }
195 
            }
196 
            $sth->finish();
197 
        }
198 
    }
199 
    else
200 
    {
201 
        Error("Prepare failure" );
202 
    }
203 
 
204 
}
205 
 
206 
#-------------------------------------------------------------------------------
207 
# Function        : GetDepends
208 
#
209 
# Description     : Extract the dependancies for a given package version
210 
#
211 
# Inputs          : $pvid
212 
#
213 
# Returns         :
214 
#
215 
sub GetDepends
216 
{
217 
    my ($pv_id, $pname, $pver ) = @_;
218 
Message ("GetDepends: $pv_id, $pname, $pver");
219 
 
220 
    #
221 
    #   Now extract the package dependacies
222 
    #
223 
    my $m_sqlstr = "SELECT pkg.PKG_NAME, pv.PKG_VERSION, pd.DPV_ID, pv.IS_DEPLOYABLE" .
224 
                   " FROM PACKAGE_DEPENDENCIES pd, PACKAGE_VERSIONS pv, PACKAGES pkg" .
225 
                   " WHERE pd.PV_ID = \'$pv_id\' AND pd.DPV_ID = pv.PV_ID AND pv.PKG_ID = pkg.PKG_ID";
226 
    my $sth = $RM_DB->prepare($m_sqlstr);
227 
    if ( defined($sth) )
228 
    {
229 
        if ( $sth->execute( ) )
230 
        {
231 
            if ( $sth->rows )
232 
            {
233 
                my %depends;
234 
                while ( my @row = $sth->fetchrow_array )
235 
                {
236 
#                    print "$name ===== @row\n";
237 
                    my $name = $row[0];
238 
                    my $ver = $row[1];
239 
                    my $deployable = $row[3];
240 
Message ("   $name, $ver");
241 
 
242 
                    if ($opt_no_ver)
243 
                    {
244 
                        push @{$Package{$name}{'xxx'}{ver_list}}, $ver;
245 
                        $ver = 'xxx';
246 
                    }
247 
 
248 
                    $depends{$name,$ver} = 1;
249 
                    push @{$Package{$name}{$ver}{usedby}}, [ $pname, $pver ];
250 
 
251 
                    unless ( exists $Package{$name}{$ver}{done} )
252 
                    {
253 
                        $Package{$name}{$ver}{needed} = 1;
254 
                        $Package{$name}{$ver}{deployable} = 1 if ($deployable);
255 
 
256 
                        my @DATA = ($name, $ver, $row[2]);
257 
                        push @StrayPackages, \@DATA;
258 
                    }
259 
                }
260 
                $Package{$pname}{$pver}{depends} = \%depends;
261 
            }
262 
            $sth->finish();
263 
        }
264 
    }
265 
    else
266 
    {
267 
        Error("GetDepends:Prepare failure" );
268 
    }
269 
}
270 
 
271 
#-------------------------------------------------------------------------------
272 
# Function        : LocateStrays
273 
#
274 
# Description     :
275 
#
276 
# Inputs          :
277 
#
278 
# Returns         :
279 
#
280 
sub LocateStrays
281 
{
282 
 
283 
    while ( $#StrayPackages >= 0 )
284 
    {
285 
        my $DATA = pop @StrayPackages;
286 
        my $name = $DATA->[0];
287 
        my $ver = $DATA->[1];
288 
        my $pv_id = $DATA->[2];
289 
 
290 
        next if ( exists $Package{$name}{$ver}{done} );
291 
        GetDepends(  $pv_id, $name, $ver );
292 
        $Package{$name}{$ver}{done} = 1;
293 
        $Package{$name}{$ver}{stray} = 1;
294 
    }
295 
}
296 
 
297 
#-------------------------------------------------------------------------------
298 
# Function        : BuildOrder
299 
#
300 
# Description     : Determine the order to build packages
301 
#
302 
# Inputs          :
303 
#
304 
# Returns         :
305 
#
306 
sub BuildOrder
307 
{
308 
    foreach my $name ( keys %Package )
309 
    {
310 
        foreach my $ver ( keys %{$Package{$name}} )
311 
        {
312 
            AddToBuildList( $name, $ver, $Package{$name}{$ver}{depends} );
313 
        }
314 
    }
315 
 
316 
    DetermineBuildOrder();
317 
}
318 
 
319 
#-------------------------------------------------------------------------------
320 
# Function        : AddToBuildList
321 
#
322 
# Description     : Add packages to a build list
323 
#
324 
# Inputs          : PackageName
325 
#                   PackageVersion
326 
#                   Hash of dependancies
327 
#
328 
# Returns         :
329 
#
330 
my %BuildList;
331 
sub AddToBuildList
332 
{
333 
    my ($name, $ver, $pdepends ) = @_;
334 
 
335 
    print "Duplicate Package to build: $name, $ver\n" if exists $BuildList{$name,$ver};
336 
    $BuildList{$name,$ver}{depends} = $pdepends;
337 
}
338 
 
339 
#-------------------------------------------------------------------------------
340 
# Function        : DetermineBuildOrder
341 
#
342 
# Description     : Determine the build order
343 
#
344 
# Inputs          :
345 
#
346 
# Returns         :
347 
#
348 
sub DetermineBuildOrder
349 
{
350 
 
351 
#    DebugDumpData ("BuildList", \%BuildList); exit 1;
352 
 
353 
    my $more = 1;
354 
    my $level = 0;
355 
    while ( $more )
356 
    {
357 
        my @build;
358 
        $level ++;
359 
        $more = 0;
360 
        foreach my $key ( keys %BuildList )
361 
        {
362 
            #
363 
            #   Locate packges with no dependencies left
364 
            #
365 
            next if ( keys %{$BuildList{$key}{depends}} );
366 
            push @build, $key;
367 
        }
368 
 
369 
        foreach my $build ( @build )
370 
        {
371 
            $more = 1;
372 
            delete $BuildList{$build};
373 
            my ($name, $ver) = split $;, $build;
374 
 
375 
#            next if ( exists $Package{$name}{$ver}{stray} );
376 
 
377 
            my $dpkg = $Package{$name}{$ver}{dpkg} || '';
378 
            my $label = $Package{$name}{$ver}{label} || '';
379 
            my $path = $Package{$name}{$ver}{path} || '';
380 
 
381 
 
382 
            printf( "Build(%2d): %25s %15s %-40s %s\n", $level, $name, $ver, $label, $path);
383 
        }
384 
 
385 
        #
386 
        #   Delete dependencies
387 
        #
388 
        foreach my $key ( keys %BuildList )
389 
        {
390 
            foreach my $build ( @build )
391 
            {
392 
                delete $BuildList{$key}{depends}->{$build};
393 
            }
394 
        }
395 
    }
396 
}
397 
 
398