Subversion Repositories DevTools

#!/usr/local/bin/perl -w

require 5.8.2;

use Getopt::Std;

use DeployUtils::Logger;

use vars qw ( $opt_l $opt_h $opt_a $opt_A $opt_d $opt_D $opt_y );

getopts('l:haAdDy');

help() if ( defined($opt_h) );

help("Must supply nodespec file & new version number as args") if ( !defined($ARGV[0]) || !defined($ARGV[1]) );

help("Cant use -a & -A together") if ( defined($opt_a) && defined($opt_A) );

help("Cant use -d & -D together") if ( defined($opt_d) && defined($opt_D) );

setLogLevel($opt_l) if ( defined($opt_l) );

my $ver = shift;

my $retval;

while ( my $nsfile = shift )

{

    $retval = pkgmnt::init($ver, $nsfile,

                            (defined($opt_d)) ? "NO" : (defined($opt_D)) ? "YES" : "ASK",

                            (defined($opt_a)) ? "NO" : (defined($opt_A)) ? "YES" : "ASK",

                            (defined($opt_y)) ? 1 : 0 );

    $retval = pkgmnt::getNodeSpecFromDM() if ( $retval );

    if ( $retval )

    {

        pkgmnt::checkForDeleted();

        pkgmnt::checkForNew();

        pkgmnt::mergeHashs();

        $retval = pkgmnt::updateNodeSpecFile();

    }

    LogError("-x", "Unable to process Nodespec file [$nsfile]") if ( ! $retval );

}

sub help

{

    my $error = shift;

    my $usage = qq(

updateNodeSpec.pl [-l N] [-d|-D] [-a|-A] [-y] NewVersion nodespecfile 

where

    NewVersion   : The new BOM version for the nodespec file.

    nodespecfile : Specifies the nodespec file to update.

Options:

    -l  : Sets log level 1-5

    -d  : Dont Automatically Delete packages from nodespec file if DM does not have them.

    -D  : Do Automatically Delete packages from nodespec file if DM does not have them.

        : DEFAULT if neither supplied is to interactively ask for each package.

    -a  : Dont Automatically Add new packages from DM into nodespec file.

    -A  : Do Automatically Add new packages from DM into nodespec file.

        : DEFAULT if neither supplied is to interactively ask for each package.

    -y  : Automatically answer yes to final Update nodespec file question.

    );

    print "$error\n" if ( defined $error );

    print $usage;

    exit 1;

}

#============================================================================

package pkgmnt;

use strict;

use DBI;

use Data::Dumper;

use DeployUtils::Logger;

use JatsRmApi;

our ($G_NodeSBOMVersion, $G_NodeName, %G_NodeProcessHash, %G_NodePkgHash, %G_NodeDmInfo);

our %newPkgs;

our ( @actionlog, $actions );

our $nodeSpecFile;

our ( $newVer, $bomver, $lifecycle );

our ( $autoDelete, $autoAdd, $autoUpdate );

sub init

{

    ( $newVer, $nodeSpecFile, $autoDelete, $autoAdd, $autoUpdate ) = @_;

    LogNorm("");

    LogNorm("");

    LogNorm("Upgrading NodeSpec file [$nodeSpecFile] to $newVer");

    if ( ! -f $nodeSpecFile )

    {

        LogError("-x", "Nodespec file [$nodeSpecFile] does not exist");

        return 0;

    }

    # version must start & end with numbers and contain numbers & '.' in between

    if ( $newVer =~ /^[0-9]+[0-9\.]*[0-9]+$/ )

    {

        # split version number into number sections

        my @verNums = split(/\./, "$newVer");

        #last section is the lifecycle number so remove from list

        $lifecycle = pop(@verNums);

        #now join rest of numbers

        $bomver = join(".", @verNums);

    }

    else

    {

        LogError("-x", "Version number format incorrect, must contain digits & '.' eg (1.2 or 1.1.2)");

        return 0;

    }

    $autoDelete = uc $autoDelete;

    $autoAdd = uc $autoAdd;

    if ( $autoDelete ne "YES" && $autoDelete ne "NO" && $autoDelete ne "ASK" )

    {

        LogError("-x", "autoDelete flag must be YES, NO or ASK");

        return 0;

    }

    if ( $autoAdd ne "YES" && $autoAdd ne "NO" && $autoAdd ne "ASK" )

    {

        LogError("-x", "autoAdd flag must be YES, NO or ASK");

        return 0;

    }

    $Data::Dumper::Purity = 1;

    $Data::Dumper::Quotekeys = 0;

    $Data::Dumper::Sortkeys = 1;

    $Data::Dumper::Indent = 1;

    $G_NodeSBOMVersion = "";

    $G_NodeName = "";

    %G_NodeProcessHash = ( );

    %G_NodePkgHash = ( );

    %G_NodeDmInfo = ( );    

    %newPkgs = ( );

    $#actionlog = -1;

    $actions = 0;

    # require the nodespk file to get details

    require $nodeSpecFile;

    if ( ! defined($G_NodeDmInfo{ProjectName}) && ! defined($G_NodeDmInfo{BranchName}) &&

         ! defined($G_NodeDmInfo{BomName}) && ! defined($G_NodeDmInfo{NodeName}) &&

         ! defined($G_NodeDmInfo{OsName}) )

    {

        LogError("-x", "G_NodeDmInfo hash in nodespec does not have enough info");

        return 0;

    }

    LogInfo("ProjectName : $G_NodeDmInfo{ProjectName}");

    LogInfo("BranchName  : $G_NodeDmInfo{BranchName}");

    LogInfo("BomName     : $G_NodeDmInfo{BomName}");

    LogInfo("NodeName    : $G_NodeDmInfo{NodeName}");

    LogInfo("OsName      : $G_NodeDmInfo{OsName}");

    return 1;

}

sub getNodeSpecFromDM

{

    my $DM;

    connectDM( \$DM );

    my ($m_sqlstr ) = qq /

SELECT oc.prod_id, pkg.pkg_name, pv.pkg_version, pv.pv_description, pv.v_ext, pv.is_patch

FROM deployment_manager.dm_projects dm_,

     deployment_manager.branches branches,

     deployment_manager.boms boms,

     deployment_manager.bom_names bom,

     deployment_manager.network_nodes net,

     deployment_manager.bom_contents bomcont,

     deployment_manager.operating_systems ope,

     deployment_manager.os_contents oc,

     release_manager.package_versions pv,

     release_manager.PACKAGES pkg

WHERE ( (dm_.proj_id = branches.proj_id) AND (branches.branch_id = boms.branch_id) AND

        (bom.bom_name_id = boms.bom_name_id) AND (boms.bom_id = bomcont.bom_id) AND

        (net.node_id = bomcont.node_id) AND (net.node_id = ope.node_id) AND

        (ope.os_id = oc.os_id) AND (oc.prod_id = pv.pv_id) AND (pv.pkg_id = pkg.pkg_id) AND

        (dm_.proj_name = '$G_NodeDmInfo{ProjectName}') AND

        (branches.branch_name = '$G_NodeDmInfo{BranchName}') AND

        (bom.bom_name = '$G_NodeDmInfo{BomName}') AND

        (boms.bom_version = '$bomver') AND

        (boms.bom_lifecycle = '$lifecycle') AND

        (net.node_name = '$G_NodeDmInfo{NodeName}') AND

        (ope.os_name = '$G_NodeDmInfo{OsName}')

       )

    /;

    my ($sth )  = $DM->prepare($m_sqlstr);

    my @row;

    my $found = 0;

    LogDebug("Executing SQL statement\n$m_sqlstr");

    if ( defined($sth) )

    {

        if ( $sth->execute() )

        {

            if ( $sth->rows )

            {

                while ( @row = $sth->fetchrow_array )

                {

                    # Skip Patches

                    if ( !defined($row[5]) || $row[5] !~ /y/i )

                    {

                        # if extension defined

                        if ( defined($row[4]) )

                        {

                            # remove dot from start of extension

                            $row[4] =~ s/^\.//;

                            # remove extension from version

                            if ( $row[2] =~ /\.$row[4]$/ )

                            {

                                $row[2] =~ s/\.$row[4]$//;

                            }

                            else

                            {

                                LogWarn("Pkg [$row[1]] version [$row[2]] & extension [$row[4]] do not match");

                            }

                        }

                        else

                        {

                            $row[4] = "";

                        }

                        $row[3] = "" if ( ! defined($row[3]) );

                        chomp $row[3];

                        # if pkg version defined in _Forceversion then we  force the version

                        if ( defined($G_NodeDmInfo{_ForceVersion}{$row[1]}) && defined($G_NodeDmInfo{_ForceVersion}{$row[1]}{$row[2]}))

                        {

                            LogDebug("Forcing pkg [$row[1]] from version [$row[2]] to [$G_NodeDmInfo{_ForceVersion}{$row[1]}{$row[2]}]");

                            $newPkgs{$row[1]}{PkgVersion}   = $G_NodeDmInfo{_ForceVersion}{$row[1]}{$row[2]};

                        }

                        else

                        {

                            $newPkgs{$row[1]}{PkgVersion}   = $row[2];

                        }

                        $newPkgs{$row[1]}{PkgProjAcronym}   = $row[4];

                        $newPkgs{$row[1]}{PkgDesc}          = $row[3];

                        $found = 1;

                        LogDebug("Found DM Pkg [$row[1]], ver [$row[2]], proj [$row[4]], desc [$row[3]]");

                    }

                }

            }

            if ( ! $found )

            {

                LogError("-x", "Found No Information about node in Deployment Manager");

                return 0;

            }            

            $sth->finish();

        }

        else

        {

            LogError("-x", "Unable to execute SQL statement in DBI");

            return 0;

        }

    }

    else

    {

        LogError("-x", "Unable to prepare SQL statement in DBI");

        return 0;

    }

    disconnectDM(\$DM);

    return 1;

}

sub checkForDeleted

{

    foreach my $i ( keys %G_NodePkgHash )

    {

        # if pkg not defined in newPkgs from DM AND its not in the NoDelete List then we ask or process

        # that is is pkg is not in DM but it is in NoDelete list then we keep it as if it was

        if ( ! defined($newPkgs{$i}) && ! defined($G_NodeDmInfo{_NoDelete}{$i}) )

        {

            # ask if neither -d or -D set

            my $ans = "";

            $ans = askYN("Pkg [$i] is not in new list, remove") if ( $autoDelete eq "ASK" );

            # if -d defined or asn = N then we dont delete so just log

            if ( $autoDelete eq "NO" || $ans eq "N" )

            {

                push(@actionlog, "KEEP   Old Pkg [$i]: Version [$G_NodePkgHash{$i}{PkgVersion}] Project [$G_NodePkgHash{$i}{PkgProjAcronym}] from original Nodespec");

                # keeping an old package is not a real action, as nothing changes in nodespec

            }

            # if -D defined or ans = Y then delete

            elsif ( $autoDelete eq "YES" || $ans eq "Y" )

            {

                push(@actionlog, "DELETE Old Pkg [$i]: Version [$G_NodePkgHash{$i}{PkgVersion}] Project [$G_NodePkgHash{$i}{PkgProjAcronym}] from original Nodespec");

                delete($G_NodePkgHash{$i});

                $actions++;

            }

        }

    }

}

sub checkForNew

{

    foreach my $i ( keys %newPkgs )

    {

        if ( ! defined($G_NodePkgHash{$i}) )

        {

            # if pkg is defined in noAdd list then we just remove, otherwise process as normal

            if ( defined($G_NodeDmInfo{_NoAdd}{$i}) )

            {

                delete($newPkgs{$i});

            }

            else

            {

                # ask if neither -d or -D set

                my $ans = "";

                $ans = askYN("Pkg [$i] has been added, add") if ( $autoAdd eq "ASK" );

                # if -A defined or ans = Y then we add so just log

                if ( $autoAdd eq "YES" || $ans eq "Y" )

                {

                    push(@actionlog, "ADD    New Pkg [$i]: Version [$newPkgs{$i}{PkgVersion}] Project [$newPkgs{$i}{PkgProjAcronym}] from Deployment Manager");

                    $actions++;

                }

                # if -a defined then dont Add (remove from dm list), otherwise ask

                elsif ( $autoAdd eq "NO" || $ans eq "N" )

                {

                    push(@actionlog, "SKIP   New Pkg [$i]: Version [$newPkgs{$i}{PkgVersion}] Project [$newPkgs{$i}{PkgProjAcronym}] from Deployment Manager");

                    delete($newPkgs{$i});

                    # deleting a new package is not a real action, as nothing changes in nodespec

                }

            }

        }

    }

}

sub mergeHashs

{

    my $str;

    my $updated;

    foreach my $i ( keys %newPkgs )

    {

        if ( defined($G_NodePkgHash{$i}) )

        {

            $str = "UPDATE Pkg [$i]: ";

            $updated = 0;

            if ( $newPkgs{$i}{PkgVersion} ne $G_NodePkgHash{$i}{PkgVersion} )

            {

                $str .= "Version [$G_NodePkgHash{$i}{PkgVersion}]=>[$newPkgs{$i}{PkgVersion}] ";

                $updated = 1;

                $G_NodePkgHash{$i}{PkgVersion} = $newPkgs{$i}{PkgVersion};

            }

            if ( ($newPkgs{$i}{PkgProjAcronym} || '') ne ($G_NodePkgHash{$i}{PkgProjAcronym} || '') )

            {

                $str .= "Project [$G_NodePkgHash{$i}{PkgProjAcronym}]=>[$newPkgs{$i}{PkgProjAcronym}] ";

                $updated = 1;

                if ( $newPkgs{$i}{PkgProjAcronym} )

                {

                    $G_NodePkgHash{$i}{PkgProjAcronym} = $newPkgs{$i}{PkgProjAcronym};

                }

                else

                {

                    delete $G_NodePkgHash{$i}{PkgProjAcronym};

                }

            }

            if ( $newPkgs{$i}{PkgDesc} ne $G_NodePkgHash{$i}{PkgDesc} )

            {

                $str .= "Description [$G_NodePkgHash{$i}{PkgDesc}]=>[$newPkgs{$i}{PkgDesc}] ";

                $updated = 1;

                $G_NodePkgHash{$i}{PkgDesc} = $newPkgs{$i}{PkgDesc};

            }

            if ( $updated )

            {

                push(@actionlog, $str);

                $actions++;

            }

        }

        else

        {

            $G_NodePkgHash{$i}{PkgVersion} = $newPkgs{$i}{PkgVersion};

            $G_NodePkgHash{$i}{PkgProjAcronym} = $newPkgs{$i}{PkgProjAcronym};

            $G_NodePkgHash{$i}{PkgDesc} = $newPkgs{$i}{PkgDesc};

            $G_NodePkgHash{$i}{ERGPkgFlag} = "T";

            $G_NodePkgHash{$i}{CheckVersionFlag} = "T";

            # no need to log as its already done

        }

    }

}

sub updateNodeSpecFile

{

    my ( $buffer, $line );

    LogNorm("--------------------------------------------------------------------");

    if ( $G_NodeSBOMVersion eq $newVer && $actions == 0 )

    {

        LogNorm("NO ACTIONS will be performed on the nodespec file [$nodeSpecFile]");

        LogNorm("--------------------------------------------------------------------");

    }

    else

    {

        LogNorm("The Following actions will be performed on the nodespec file [$nodeSpecFile]");

        LogNorm("UPDATE BOM version from $G_NodeSBOMVersion to $newVer");

        foreach my $i ( sort @actionlog )

        {

            LogNorm($i);

        }

        LogNorm("--------------------------------------------------------------------");

        if ( $autoUpdate || askYN("Update nodespec file as described ") eq "Y" )

        {

            # read all comment lines up to first comment line

            if ( ! open(NODESPEC, "<$nodeSpecFile") )

            {

                LogError("-x", "Unable to open Node Spec File to update");

                return 0;

            }

            do

            {

                $line = <NODESPEC>;

                $line =~ s/\r\n/\n/;

                $buffer .= $line if ( $line =~ /^#/ );

            }

            while ( $line =~ /^#/ );

            close NODESPEC;

            # now lets update the file

            if ( ! open(NODESPEC, ">$nodeSpecFile") ) 

            {

                LogError("-x", "Unable to open Node Spec File to update");

                return 0;

            }

            binmode(NODESPEC);

            print NODESPEC "$buffer\n";

            # Dumper prints hashes as references ie $hash = { .... };

            # Where the original nodespec files were real hashes ie %hash = ( .... );

            # So we dump hashes to buffer and replace the first line with real hash & (

            # and replace last line }; with );

            $buffer = Data::Dumper->Dump([ \%G_NodeDmInfo ], [ "pkgmnt::G_NodeDmInfo" ]);

            $buffer =~ s/^\$(pkgmnt::G_NodeDmInfo *= *)\{(.*)\}(.*)$/\%$1\($2\)$3/ms;

            print NODESPEC "$buffer\n";

            print NODESPEC Data::Dumper->Dump([ $newVer ], [ "pkgmnt::G_NodeSBOMVersion" ]) . "\n";

            print NODESPEC Data::Dumper->Dump([ $G_NodeName ], [ "pkgmnt::G_NodeName" ]) . "\n";

            $buffer = Data::Dumper->Dump([ \%G_NodeProcessHash], [ "pkgmnt::G_NodeProcessHash" ]);

            $buffer =~ s/^\$(pkgmnt::G_NodeProcessHash *= *)\{(.*)\}(.*)$/\%$1\($2\)$3/ms;

            print NODESPEC "$buffer\n";

            $buffer = Data::Dumper->Dump([ \%G_NodePkgHash ], [ "pkgmnt::G_NodePkgHash" ]);

            $buffer =~ s/^\$(pkgmnt::G_NodePkgHash *= *)\{(.*)\}(.*)$/\%$1\($2\)$3/ms;

            print NODESPEC "$buffer\n1;\n";

            close NODESPEC;

            LogNorm("Updated nodespec file $nodeSpecFile");

        }

    }

    return 1;

}

sub askYN

{

    use Term::ReadKey;

    my $msg = shift;

    $msg .= " [ynq] ? ";

    my $ch = "";

    my $rMode = 0;

    while ( $ch ne "Y" && $ch ne "N" )

    {

        LogNorm("-n", $msg);

        #$ch = uc HotKey::readkey();

        eval { ReadMode('cbreak'); $rMode = 1 }; # do in eval because it barfs on cygwin term

        $ch = uc ReadKey(0);

        eval { ReadMode('normal') };

        chomp $ch;

        if ( $rMode )

        {

            print "\n";

        }

        else

        {

            # if not rMode then a CR needs to be entered so lets remove it.

            my $a = <STDIN>;

        }

        LogError("Quitting application") if ( $ch eq "Q" );

    }

    return $ch;

}

1;

#============================================================================

# HotKey.pm

#package HotKey;

#use strict;

#use POSIX qw(:termios_h);

#my ($term, $oterm, $echo, $noecho, $fd_stdin);

#BEGIN {

#$fd_stdin = fileno(STDIN);

#$term     = POSIX::Termios->new();

#$term->getattr($fd_stdin);

#$oterm     = $term->getlflag();

#$echo     = ECHO | ECHOK | ICANON;

#$noecho   = $oterm & ~$echo;

#}

#sub cbreak {

#    $term->setlflag($noecho);  # ok, so i don't want echo either

#    $term->setcc(VTIME, 1);

#    $term->setattr($fd_stdin, TCSANOW);

#}

#sub cooked {

#    $term->setlflag($oterm);

#    $term->setcc(VTIME, 0);

#   $term->setattr($fd_stdin, TCSANOW);

#}

#sub readkey {

#    my $key = '';

#    cbreak();

#    sysread(STDIN, $key, 1);

#    cooked();

#    return $key;

#}

#END { cooked() }

#1;