Subversion Repositories DevTools

# Description:

#

#

require 5.6.1;

                    &generateXmlDependancy

#-------------------------------------------------------------------------------

# Function        : generateXmlDependancy

#

# Description     : Generate an XML file that describes the despendencies of the

#                   released package.

#

#                   The generated file needs to be packaged for deployment. This

#                   function will only create the file. It needs to be added to the

#                   files that are deployed into the field. The file is primarily

#                   to be used by Windows based applications, but its use may be

#                   extended to other platforms.

#

#                   The file 'should' be deployed in the same directory as the main

#                   application executable, so that the executable may locate it.

#

#                   The XML file is named after the package. It is prefixed with

#                   the string "PkgInfo_".

#

#                   By default file will be placed in the 'TargetBaseDir'.

#                   This behaviour may be modified by the user.

#

#                   Refer to package_info.xsd for details on the structure of the

#                   generated XML file. Do not randomly chnage the structure.

#                   It is being used.

#

#                   This function requires access to Release Manager in order

#                   to locate the package description and build-time information

#

#                   The function will use the current/last version of the package

#                   in an attempt to locate package information.

#

#

# Inputs          : platform        - Platforms for which the file will be created

#                                     '*' indicate ALL platforms.

#                   options         - Options to control the detail of the generated file

#

#                   Valid options

#                       --TargetDir         - Symbolic target directory

#                                             Default: TargetBaseDir

#

#                       --Depth=nn          - Depth to traverse the dependancy tree

#                                             All packages below this depth will be ignored

#                                             Default: 0. All packages will be included

#                       --VisibleDepth=nn   - Package beyond this depth will be marked as invisible

#                                             Default: 1. Only top level packages will be marked

#                                             as visible.

#                       --Ignore=name       - Ignore this package

#                                             It will not be included in the dependancy list

#                                             Default: None

#                       --IgnoreChildren=name   - Do not include children of this package\

#                                             Default: None

#                       --Invisible=name    - Mark this package and its dependents as invisible

#                                             Default: None

#                       --InvisibleChildren=name

#                                           - Mark this package as visible, but its dependents as invisible

#                                             Default: None

#

# Example:

#               generateXmlDependancy('*', '--TargetDir=OcpDir' );

#               

#

# Returns         : Nothing

#

sub generateXmlDependancy

{

    my ($platforms, @opts) = @_;

    my %data;

    my $filename = "PkgInfo_$PkgName" . '.xml';

    my $targetTag;

    return if ( ! ActivePlatform($platforms) );

    Information("Generating XML dependancy information from RM data: $filename");

    #

    #   Insert defaults

    #

    $data{default_visible} = 1;

    #

    #   Parse the user options

    #

    foreach ( @opts )

    {

        if ( m/^--Depth=(\d+)/ ) {

            $data{default_depth} = $1;

        } elsif ( m/^--VisibleDepth=(\d+)/ ) {

            $data{default_visible} = $1;

        } elsif ( m/^--Ignore=(.*)/ ) {

            $data{ignore}{$1} = 1;

        } elsif ( m/^--IgnoreChildren=(.*)/ ) {

            $data{ignore_child}{$1} = 1;

        } elsif ( m/^--Invisible=(.*)/ ) {

            $data{invisible}{$1} = 1;

        } elsif ( m/^--InvisibleChildren=(.*)/ ) {

            $data{invisible_child}{$1} = 1;

        } elsif ( m/^--TargetDir=(.*)/ ) {

            $targetTag = $1;

        } else {

            Error ("generateXmlDependancy: Unknown option: $_");

        }

    }

    #

    #   Sanity Tests

    #

    if ( $data{default_visible} && $data{default_depth} )

    {

        Error ("generateXmlDependancy:Visible depth must be less than total depth")

            if ( $data{default_visible} > $data{default_depth} );

    }

    # lets check to see if the target tag exists

    # if does not the process with log an error.

    #

    my $targetValue;

    if ( $targetTag )

    {

        $targetValue = getTargetDstDirValue($targetTag, "A");

    }

    else

    {

        $targetValue = "$PkgBaseDir/$TargetBaseDir";

    }

    $filename = $targetValue . '/' . $filename;

    #

    #   Determine package information.

    #   Must cater for a number of situations

    #       1) Package rebuild

    #       2) Package ripple

    #       3) New package

    #

    # Set defaults for elements in RM if not found

    DeployUtils::RmPkgInfo->DefaultDescription($PkgDesc);

    DeployUtils::RmPkgInfo->DefaultLabel($PkgLabel);

    #

    #   Try with the current package version. It may be in RM

    #

    $RmPkgDetails = DeployUtils::RmPkgInfo->new( {

                        PKG_NAME => $PkgName,

                        PKG_VERSION => $PkgVersionUser,

                        NO_WARN => 1

                    } );

    unless ( $RmPkgDetails->foundDetails() && $PkgPreviousVersionStr )

    {

        #

        #   Try with the 'Previous' package

        #

        my $RmPkgDetailsPrev = DeployUtils::RmPkgInfo->new( {

                        PKG_NAME => $PkgName,

                        PKG_VERSION => $PkgPreviousVersionStr,

                        NO_WARN => 1

                    } );

        if ( $RmPkgDetailsPrev->foundDetails() )

        {

            Information ("generateXmlDependancy. Using previous version ($PkgPreviousVersionStr)");

            $RmPkgDetails = $RmPkgDetailsPrev;

        }

    }

    unless ( $RmPkgDetails->foundDetails() )

    {

        Warning ("generateXmlDependancy. Package Information not in RM. Using defaults");

    }

    #

    #   %packages   - information on packages that we have discovered

    #   @to_process - An array of packages discovered, but not yet processed

    #

    my @to_process;

    #

    #   Create the initial entry in the packages array

    #

    my @deps;

    foreach my $i ( $BuildFileInfo->getDpkgArchiveList() )

    {

        my $moduleInfo = $BuildFileInfo->getDpkgArchiveInfo($i);

        my $tag = join ($;, $i, $moduleInfo->{versionFull} );

        push @deps, $tag;

    }

    $data{packages}{$PkgName}{$PkgVersionUser}{date} = $RmPkgDetails->pv_modified_time() || localtime() ;

    $data{packages}{$PkgName}{$PkgVersionUser}{overview} = $RmPkgDetails->pv_description();

    $data{packages}{$PkgName}{$PkgVersionUser}{deps} = [ @deps ] ;

    push @to_process, @deps;

    while ( my $entry = pop @to_process )

    {

        my ($package, $version) = split ( $;, $entry );

        #

        #   Extract and save information for this package

        #

        next if ( exists $data{packages}{$package}{$version} );

        #

        #   Some packages need to be totally ignored

        #

        next if ( exists $data{ignore}{$package} );

        my $RmPkgDetails = DeployUtils::RmPkgInfo->new(

                        {

                            PKG_NAME => $package,

                            PKG_VERSION => $version,

                        } );

        Error ("generateXmlDependancy: Cannot locate base package: $package, $version")

            unless ( $RmPkgDetails->foundPkg() );

        #

        #   Determine the dependancies, unless we are ignoring the children too

        #   Do not use the RmPkgInfo class method getDependencyNames to fetch the

        #   dependancy information as this:

        #       1) gets it wrong

        #       2) Extracts a lot of data that we dont want.

        #

        my @deps;

        unless ( exists $data{ignore_child}{$package} )

        {

            my $deps = $RmPkgDetails->getDependenciesHash();

            foreach my $pkg ( keys %{$deps} )

            {

                foreach my $ver ( keys %{$deps->{$pkg}}  )

                {

                    my $tag = join ($;, $pkg, $ver );

                    push @deps, $tag;

                }

            }

        }

        $data{packages}{$package}{$version}{date} = $RmPkgDetails->pv_modified_time();

        $data{packages}{$package}{$version}{overview} = $RmPkgDetails->pv_description();

        $data{packages}{$package}{$version}{deps} = [ @deps ] ;

        push @to_process, @deps;

    }

#DebugDumpData ("Packages", \%packages);

    #

    #   Now walk the tree and generate XML

    #

    sub output_entry

    {

        my ($datap, $depth, $package, $version, $vis ) = @_;

        my $fh = $datap->{fh};

        $depth++;

        #

        #   Skip if too deep or an ignored package

        #

        return if ( $datap->{ignore}{$package} );

        return if ( $datap->{default_depth} && $depth > $datap->{default_depth} );

        #

        #   Check for invisible packages

        #

        $vis = 0 if ( $datap->{invisible}{$package} );

        my $indent = "    " x ($depth - 1);

        my $date = $datap->{packages}{$package}{$version}{date};

        my $overview = $datap->{packages}{$package}{$version}{overview};

        #

        #   Clean up the overview

        #

        $overview =~ s~\s+$~~;

        $overview =~ s~\r\n~\n~g;

        $overview =~ s~\n\r~\n~g;

        #

        #   Determine visibility

        #

        $vis = 0 if ( $datap->{default_visible} && $depth > $datap->{default_visible} );

        my $visible = ( $vis > 0 ) ? 'true' : 'false';

        $vis = 0 if ( $datap->{invisible_child}{$package} );

        #

        #   The top level entry is different

        #

        if ( $depth == 0 )

        {

            $indent = "    " ;

            print $fh "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";

            print $fh "<ERG_Package xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"package_info.xsd\" SchemaVersion=\"1.0.0\">\n";

            print $fh "$indent<Package_Name>$package</Package_Name>\n";

            print $fh "$indent<Package_Version>$version</Package_Version>\n";

            print $fh "$indent<Package_Overview>$overview</Package_Overview>\n";

            print $fh "$indent<Build_Date>$date</Build_Date>\n";

        }

        else

        {

            print $fh "${indent}<Package Name=\"$package\" Version=\"$version\" BuildDate=\"$date\" Visible=\"$visible\">\n";

		    print $fh "${indent}    ";

            print $fh "<Overview>${overview}" if ($overview);

		    print $fh "</Overview>\n";

        }

        #

        #   Process dependancies

        #

        unless ( $datap->{ignore_child}{$package} )

        {

            foreach my $entry ( @{ $datap->{packages}{$package}{$version}{deps} } )

            {

                my ($package, $version) = split ( $;, $entry );

                output_entry ( $datap, $depth, $package, $version, $vis );

            }

        }

        if ( $depth == 0 )

        {

            print $fh "</ERG_Package>\n";

        }

        else

        {

		    print $fh "${indent}</Package>\n";

        }

    }

    #

    #   Output the XML header and information about the first package

    #

    Information ( "Creating file $filename" );

    open ( $data{fh}, ">", $filename ) || Error( "Cannot create $filename");

    output_entry ( \%data, -1, $PkgName, $PkgVersionUser, 1 );

    close $data{fh};

#    DebugDumpData( "DATA", \%data );

}

#-------------------------------------------------------------------------------

# Function        : ActivePlatform

#

# Description     : Determine if the specified platform is currently 'active'

#                   This is used by all user directives in order to determine

#                   if the directive should be ignored for the current platform

#

# Inputs          : $platform_spec      - A (simple)platform specifier

#

# Returns         : TRUE if the platform spec contains the current platform

#

sub ActivePlatform

{

    my( $platform_spec ) = @_;

    Error ("No platform specified in some directive") unless ( $platform_spec );

    #

    #   Wild card

    #

    return 1 if ( $platform_spec eq '*' );

    #

    #   Simple test

    #

    foreach ( split (',', $platform_spec))

    {

        return 1 if ( $_ eq $Platform );

    }

    #

    #   Not for me

    #

    return 0;

}