You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
714 lines
22 KiB
714 lines
22 KiB
@echo off
|
|
REM ------------------------------------------------------------------
|
|
REM <<srvrel.cmd>>
|
|
REM copy the build From Build Machine to Release Servers.
|
|
REM
|
|
REM Copyright (c) Microsoft Corporation. All rights reserved.
|
|
REM Version: < 1.0 > 02/02/2001 Suemiao Rossignol
|
|
REM ------------------------------------------------------------------
|
|
perl -x "%~f0" %*
|
|
goto :EOF
|
|
#!perl
|
|
use strict;
|
|
use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
|
|
use lib $ENV{RAZZLETOOLPATH};
|
|
use Logmsg;
|
|
use ParseArgs;
|
|
use File::Basename;
|
|
use BuildName;
|
|
use GetIniSetting;
|
|
use comlib;
|
|
use cksku;
|
|
use WaitProc;
|
|
|
|
my $scriptname = basename( $0 );
|
|
|
|
sub Usage {
|
|
print<<USAGE;
|
|
|
|
Propagate builds to release servers.
|
|
|
|
Usage:
|
|
$scriptname: -l:<language> [-b:<BuildName>][-r:<SourceServer>][-xcopy ][-s][-p]
|
|
|
|
-l Language.
|
|
Default is "usa".
|
|
|
|
-b Build Name.
|
|
Default is defined in
|
|
<ReleaseShare>\\<buildName>\\build_logs\\buildname.txt for language usa.
|
|
<ReleaseShare>\\<lang>\\<buildName>\\build_logs\\buildname.txt for language none usa.
|
|
|
|
-r Alternate source server other than build machine.
|
|
Replace build machine if this is defined.
|
|
|
|
-xcopy Use xcopy as a copy command.
|
|
Default is compdir.
|
|
|
|
-s Incorporate virus scan.
|
|
|
|
-p Powerless.
|
|
Display key variables only.
|
|
|
|
-? Display Usage.
|
|
|
|
Example:
|
|
$scriptname -b:2415.x86fre.main.001222-1745 -xcopy
|
|
$scriptname -l:ger -p
|
|
|
|
USAGE
|
|
exit(1)
|
|
}
|
|
|
|
|
|
my ( $lang, $buildName, $srcServer, $useXcopy, $virusScan, $powerLess );
|
|
my ( $buildArch, $buildType );
|
|
my ( @buildMachines, $buildMachineReleaseShareName, $pullResDir );
|
|
my ( $releaseShareName, $releaseResDir, @releaseAccess, $releaseDrive );
|
|
my ( $latestReleaseShareName, $freeSpaceReq, $numBuildToKeep);
|
|
my ( @mConglomerators, $isConglomerator,$symFarm, $statusFile);
|
|
my ( %groupShareName, %groupShareRootDir );
|
|
my ( %validSkus, @validSkus, $copyCmd, $scanProg, $retryCount );
|
|
|
|
&GetParams();
|
|
if( !&InitVars() ){ exit(1);}
|
|
if( !$powerLess && !&VerifyDiskSpace ){ exit(1); }
|
|
if( !$powerLess && !&DeletePublicShare){ exit(1); }
|
|
if( !$powerLess && !&PurgeOldCdimage ){ exit(1); }
|
|
|
|
my $curRetry=0;
|
|
while( $curRetry <= $retryCount )
|
|
{
|
|
timemsg( "Auto retry count [$curRetry]." ) if( $curRetry);
|
|
if( !&LoopPullServers )
|
|
{
|
|
++$curRetry;
|
|
next;
|
|
}
|
|
if( !$powerLess && !&CreatePublicShare){ exit(1); }
|
|
timemsg( "Complete [$scriptname]" );
|
|
exit(0);
|
|
}
|
|
exit(1);
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub GetParams
|
|
{
|
|
parseargs('?' => \&Usage, 'b:' => \$buildName,'l:' =>\$ENV{lang}, 'r:' => \$srcServer,
|
|
'xcopy' =>\$useXcopy, 's' => \$virusScan, 'p' =>\$powerLess );
|
|
$ENV{lang} = "usa" if( !$ENV{lang} );
|
|
$lang = $ENV{lang};
|
|
$copyCmd = "compdir" if( !$useXcopy );
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub InitVars
|
|
{
|
|
my( @iniRequest, $iniBuildMachine, $sTemp);
|
|
my( $buildBranch, $buildNo, $iniFile, $releaseShareRootDir);
|
|
my( @releaseServers );
|
|
|
|
#####Set build name, Number, Branch, Archtecture, Type and ini file
|
|
if( !$buildName )
|
|
{
|
|
if( ! ($buildName = build_name() ))
|
|
{
|
|
my ($cmdLine ) = "$ENV{RazzleToolPath}\\postbuildscripts\\getlatestrelease.cmd -l:$lang";
|
|
return 0 if( !chomp(($buildName= `$cmdLine`)) );
|
|
}
|
|
}
|
|
|
|
#####Set LogFile & ErrFile
|
|
$ENV{temp} = "$ENV{temp}\\$lang\\$buildName";
|
|
system( "md $ENV{temp}" ) if( !(-e $ENV{temp} ) );
|
|
$ENV{LOGFILE} = "$ENV{temp}\\srvrel.log";
|
|
$ENV{ERRFILE} = "$ENV{temp}\\srvrel.err";
|
|
if(-e $ENV{LOGFILE} )
|
|
{
|
|
system( "copy $ENV{LOGFILE} $ENV{LOGFILE}.old");
|
|
system( "del $ENV{LOGFILE}" );
|
|
}
|
|
if(-e $ENV{ERRFILE} )
|
|
{
|
|
system( "copy $ENV{ERRFILE} $ENV{ERRFILE}.old") ;
|
|
system( "del $ENV{ERRFILE}" );
|
|
}
|
|
|
|
timemsg( "Start [$scriptname]" );
|
|
|
|
$buildNo = build_number($buildName);
|
|
$buildBranch = build_branch($buildName);
|
|
$buildArch = build_arch($buildName);
|
|
$buildType = build_type($buildName);
|
|
|
|
$iniFile = "$buildBranch.$lang.ini";
|
|
|
|
#####Set release servers
|
|
@iniRequest = ( "ReleaseServers::$buildArch$buildType" );
|
|
my( $iniRelServers ) = &GetIniSetting::GetSetting( @iniRequest );
|
|
if( !$iniRelServers )
|
|
{
|
|
errmsg( "no [ReleaseServers] defined in [$iniFile], exit." );
|
|
return 0;
|
|
}
|
|
@releaseServers = split( /\s+/, $iniRelServers );
|
|
|
|
|
|
#####Set build machine
|
|
if( $srcServer )
|
|
{
|
|
$iniBuildMachine = $srcServer;
|
|
}
|
|
else
|
|
{
|
|
@iniRequest = ( "BuildMachines::$buildArch$buildType");
|
|
$iniBuildMachine = &GetIniSetting::GetSetting( @iniRequest );
|
|
if( !$iniBuildMachine )
|
|
{
|
|
errmsg( "No [BuildMachines] defined in [$iniFile], exit." );
|
|
return 0;
|
|
}
|
|
}
|
|
@buildMachines = split( /\s+/, $iniBuildMachine );
|
|
|
|
for my $bldMachine ( @buildMachines )
|
|
{
|
|
if( !&comlib::ExecuteSystem( "net view $bldMachine >nul 2>nul ") )
|
|
{
|
|
errmsg( "Failed to see [$bldMachine] via net view, exit. ");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
#####Set release Share Drive
|
|
@iniRequest = ("ReleaseDrive::$ENV{computername}");
|
|
$releaseDrive = &GetIniSetting::GetSettingEx( $buildBranch,$lang,@iniRequest );
|
|
if ( !$releaseDrive )
|
|
{
|
|
$ENV{_ntdrive} =~ /(.*)\:/;
|
|
$releaseDrive = $1;
|
|
}
|
|
|
|
#####Set <ReleaseShareName> & <ReleaseShareRootDir> & <RreleaseResDir>
|
|
$buildMachineReleaseShareName = &comlib::GetReleaseShareName( $buildBranch, $lang );
|
|
|
|
#####Set $releaseShareName hard code to release for srvrel specific
|
|
$releaseShareName="release";
|
|
$releaseShareRootDir = &comlib::ParseNetShare( "release", "Path" );
|
|
if( !$releaseShareRootDir )
|
|
{
|
|
|
|
$releaseShareRootDir = "$releaseDrive:\\$releaseShareName";
|
|
}
|
|
$releaseResDir = "$releaseShareRootDir\\$lang\\$buildName";
|
|
|
|
#####Set latest share name
|
|
$latestReleaseShareName = "$buildName.$lang";
|
|
|
|
#####Set Push Dir
|
|
|
|
$statusFile = "$ENV{temp}\\SrvRelFailed.txt";
|
|
|
|
&comlib::ExecuteSystem( "md $releaseResDir" ) if( !( -e $releaseResDir ) );
|
|
|
|
&comlib::ExecuteSystem( "md $releaseResDir\\build_logs" ) if( !( -e "$releaseResDir\\build_logs" ) );
|
|
|
|
wrnmsg( "Found [$statusFile], check if same process in progress, exit")if( -e $statusFile );
|
|
|
|
|
|
#####Set access user to the release share
|
|
@iniRequest = ( "ReleaseAccess" );
|
|
for my $access( @iniRequest )
|
|
{
|
|
my $iniAccess = &GetIniSetting::GetSetting( $access );
|
|
@releaseAccess = split ( /\s+/, $iniAccess );
|
|
last if( @releaseAccess );
|
|
}
|
|
@releaseAccess = ("$ENV{userDomain}\\$ENV{UserName}") if ( !@releaseAccess );
|
|
|
|
#####Set free space required & number builds to keep for the release machine
|
|
@iniRequest = ("ReleaseServerFreeSpace\:\:$ENV{computername}");
|
|
$freeSpaceReq = &GetIniSetting::GetSetting( @iniRequest );
|
|
$freeSpaceReq = 10 if ( !$freeSpaceReq);
|
|
|
|
@iniRequest = ("ReleaseServerBuildsToKeep\:\:$ENV{computername}\:\:$buildArch$buildType");
|
|
$numBuildToKeep = &GetIniSetting::GetSettingEx( $buildBranch,$lang, @iniRequest );
|
|
$numBuildToKeep = 2 if( !$numBuildToKeep );
|
|
|
|
#####Set conglomerators
|
|
@iniRequest = ( "ConglomerationServers" );
|
|
my( $iniAggServers ) = &GetIniSetting::GetSetting( @iniRequest );
|
|
if( !$iniAggServers )
|
|
{
|
|
logmsg( "no [ConglomerationServers] defined in $iniFile." );
|
|
$isConglomerator = 0;
|
|
}
|
|
else
|
|
{
|
|
@mConglomerators = split( /\s+/, $iniAggServers );
|
|
$isConglomerator = 1;
|
|
$isConglomerator = 0 if (!grep /^$ENV{computername}$/i, @mConglomerators);
|
|
}
|
|
|
|
#####Set Symbol Servers
|
|
$symFarm = &GetIniSetting::GetSettingEx( $buildBranch,$lang,"SymFarm" );
|
|
|
|
#####Share name and Share root dir for each group item
|
|
%groupShareRootDir = ( "lang" => "$releaseShareRootDir\\$lang\\$buildNo.$buildBranch",
|
|
"build" => "$releaseShareRootDir\\misc\\$buildNo.$buildBranch" );
|
|
%groupShareName = ( "lang" => "$buildNo.$buildBranch.$lang",
|
|
"build" => "$buildNo.$buildBranch.misc" );
|
|
|
|
#####Define Valid Skus for the given languages and Architecture
|
|
%validSkus = &cksku::GetSkus( $lang, $buildArch );
|
|
@validSkus = keys %validSkus;
|
|
|
|
#####Verify if virus scan is applied in ini file
|
|
#####when it is undefined from comman line
|
|
if( !$virusScan )
|
|
{
|
|
@iniRequest = ("VirusScan::$ENV{computername}");
|
|
$virusScan = &GetIniSetting::GetSetting( @iniRequest );
|
|
if ( $virusScan eq "true" ){ $virusScan = 1; } else { $virusScan = 0; }
|
|
}
|
|
|
|
#####Find the location of virus scan executable
|
|
if( $virusScan )
|
|
{
|
|
my $tmp = "\\.\\tmp.txt";
|
|
if( system( "where inocmd32.exe > $tmp" ) )
|
|
{
|
|
wrnmsg( "inocmd32.exe is not installed in this machine, skip virus scan.");
|
|
$virusScan = 0;
|
|
}
|
|
my @tmp = &comlib::ReadFile( $tmp );
|
|
$scanProg = $tmp[0];
|
|
}
|
|
|
|
#####Define Auto-retry count used when fails on releasing
|
|
@iniRequest = ("AutoRetryReleaseCount::$ENV{computername}");
|
|
$retryCount=0 if( !($retryCount = &GetIniSetting::GetSetting( @iniRequest ) ) );
|
|
|
|
logmsg( "TEMP Dir .................[$ENV{temp}]" );
|
|
logmsg( "Log file ................[$ENV{LOGFILE}]" );
|
|
logmsg( "Error file ..............[$ENV{ERRFILE}]" );
|
|
logmsg( "Lauguage ................[$lang]" );
|
|
logmsg( "Copy command .............[$copyCmd]" );
|
|
logmsg( "Is Virus Scan ............[$virusScan]" );
|
|
logmsg( "Virus Scan File...........[$scanProg]" );
|
|
logmsg( "Build name ...............[$buildName]" );
|
|
logmsg( "Valid Skus ...............[@validSkus]" );
|
|
logmsg( "ini file ................[$iniFile]" );
|
|
logmsg( "Build Machine ............[$iniBuildMachine]" );
|
|
logmsg( "Alternate Source server...[$srcServer]" );
|
|
logmsg( "This computer ............[$ENV{computername}]" );
|
|
logmsg( "Release Servers ..........[$iniRelServers]");
|
|
logmsg( "Conglomerators ...........[$iniAggServers]" );
|
|
logmsg( "Release Drive ............[$releaseDrive]" );
|
|
logmsg( "Release share Resource ...[$releaseResDir]" );
|
|
logmsg( "Latest release Share name [$latestReleaseShareName]" );
|
|
logmsg( "Release Access ...........[@releaseAccess]" );
|
|
logmsg( "Free space required ......[$freeSpaceReq G]" );
|
|
logmsg( "Number builds to keep ....[$numBuildToKeep]" );
|
|
logmsg( "Is Conglomerator..........[$isConglomerator]" );
|
|
if( $isConglomerator )
|
|
{
|
|
for my $key ( sort keys %groupShareName )
|
|
{
|
|
logmsg( "Conglomeration share name:Path [$groupShareName{$key}:$groupShareRootDir{$key}]" );
|
|
}
|
|
}
|
|
logmsg( "Symbol Server.............[$symFarm]" );
|
|
logmsg( "Status File ..............[$statusFile]" );
|
|
logmsg( "Auto Retry count .........[$retryCount]" );
|
|
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub LoopPullServers
|
|
{
|
|
#####Set Pull Dir
|
|
my $anyPullRes=0;
|
|
|
|
for ( my $inx =0; $inx< @buildMachines; $inx++ )
|
|
{
|
|
if( $srcServer )
|
|
{
|
|
$pullResDir = "\\\\$buildMachines[$inx]\\$releaseShareName\\$lang\\$buildName";
|
|
}
|
|
else
|
|
{
|
|
if( lc($lang) eq "usa")
|
|
{
|
|
$pullResDir = "\\\\$buildMachines[$inx]\\$buildMachineReleaseShareName\\$buildName";
|
|
}
|
|
else
|
|
{
|
|
$pullResDir = "\\\\$buildMachines[$inx]\\$buildMachineReleaseShareName\\$lang\\$buildName";
|
|
}
|
|
}
|
|
if( system ( "dir $pullResDir>nul 2>nul" ) )
|
|
{
|
|
wrnmsg( "[$pullResDir] not exists in [$buildMachines[$inx]]." );
|
|
next;
|
|
}
|
|
$anyPullRes = 1;
|
|
logmsg( "Pull Path ................[$pullResDir]" );
|
|
return 0 if( !$powerLess && !&RemoteRelease );
|
|
}
|
|
if( !$anyPullRes )
|
|
{
|
|
errmsg( "[$buildName] not found in [@buildMachines] for [$lang]" );
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub RemoteRelease
|
|
{
|
|
my ( $cmdLine, $cmdLine2, $evtList, @copyList );
|
|
|
|
|
|
if( !( open FILE, ">$statusFile" ) ) {
|
|
errmsg("Could not open [$statusFile] file for writing: $!");
|
|
return 0;
|
|
}
|
|
print FILE "NOT RAISEABLE\n";
|
|
close FILE;
|
|
|
|
#####Collect all the dirs to be copied
|
|
my @excludeDir = keys %validSkus;
|
|
push( @excludeDir, "build_logs" );
|
|
push( @excludeDir, "Resources" );
|
|
push( @excludeDir, "symbols.pri" ) if( $symFarm );
|
|
|
|
my $tmpFile = "$ENV{TEMP}\\tmpFile";
|
|
&comlib::ExecuteSystem( "dir /b /ad $pullResDir > $tmpFile" );
|
|
@copyList = &comlib::ReadFile( $tmpFile );
|
|
unlink( $tmpFile );
|
|
|
|
for ( my $i = 0; $i < @copyList; $i++)
|
|
{
|
|
for my $theExclude ( @excludeDir )
|
|
{
|
|
if( lc($copyList[$i]) eq lc($theExclude) )
|
|
{
|
|
splice( @copyList, $i, 1);
|
|
$i--;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
unshift( @copyList, "." );
|
|
push( @copyList, "build_logs" );
|
|
|
|
#####Start up copy executiion
|
|
my $maxProc = $ENV{number_of_processors} * 2;
|
|
my @cmdAry=();
|
|
my $copyOpts;
|
|
my $virusScanOpts;
|
|
my $extCmd;
|
|
|
|
#####Allpy non-recursive flag for '.' dir
|
|
$virusScanOpts = "-NOS";
|
|
if( lc($copyCmd) eq "xcopy" )
|
|
{
|
|
$copyOpts = "/dhikr";
|
|
}
|
|
else
|
|
{
|
|
$copyOpts = "/eknstr";
|
|
}
|
|
$extCmd = "& $scanProg $virusScanOpts -LIS:$ENV{temp}\\root.scan -ARC $releaseResDir\\." if( $virusScan);
|
|
$cmdLine = "$copyCmd $copyOpts $pullResDir\\$copyList[0] $releaseResDir\\$copyList[0]$extCmd";
|
|
push( @cmdAry, $cmdLine );
|
|
|
|
#####Apply recursive flag for none '.' dirs
|
|
$virusScanOpts ="";
|
|
if( lc($copyCmd) eq "xcopy" )
|
|
{
|
|
$copyOpts = "/dhikre";
|
|
}
|
|
else
|
|
{
|
|
$copyOpts = "/eknst";
|
|
}
|
|
|
|
for( my $inx=1; $inx < @copyList; $inx++)
|
|
{
|
|
$extCmd = "& $scanProg $virusScanOpts -LIS:$ENV{temp}\\$copyList[$inx].scan -ARC $releaseResDir\\$copyList[$inx]" if( $virusScan);
|
|
$cmdLine = "$copyCmd $copyOpts $pullResDir\\$copyList[$inx] $releaseResDir\\$copyList[$inx]$extCmd";
|
|
push( @cmdAry, $cmdLine );
|
|
}
|
|
|
|
return 0 if( !&WaitProc::wait_proc( $maxProc, @cmdAry ) );
|
|
|
|
if( $srcServer )
|
|
{
|
|
if( !$powerLess && !system( "dir $releaseResDir\\build_logs\\*qly" ) )
|
|
{
|
|
&comlib::ExecuteSystem( "del $releaseResDir\\build_logs\\*qly" );
|
|
}
|
|
}
|
|
#####Copy conglomerators again to different pathes if this is conglomerator
|
|
if( $isConglomerator ){ return 0 if ( !&MiscCopy ); }
|
|
|
|
#####Call cdimage & filechk
|
|
return 0 if (!&PostCopy);
|
|
|
|
#####Summery of Virus Scan
|
|
&VirusScanSummary if( $virusScan );
|
|
|
|
#####Check error logs
|
|
|
|
if( -e $ENV{errfile} && !(-z $ENV{errfile}) )
|
|
{
|
|
logmsg("Please check error at $ENV{errfile}");
|
|
return 0;
|
|
}
|
|
|
|
unlink $statusFile if( -e $statusFile );
|
|
|
|
|
|
logmsg("srvrel Copy Successfully");
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub MiscCopy
|
|
{
|
|
my ( $cmdLine, $copyFlag );
|
|
|
|
for my $theGroup ( keys %groupShareName )
|
|
{
|
|
|
|
&comlib::ExecuteSystem("md $groupShareRootDir{$theGroup}" )if( !( -e $groupShareRootDir{$theGroup}) );
|
|
if( system( "net share $groupShareName{$theGroup} >nul 2>nul" ) )
|
|
{
|
|
$cmdLine = "rmtshare \\\\$ENV{computerName}\\$groupShareName{$theGroup}=$groupShareRootDir{$theGroup}";
|
|
$cmdLine .= " /grant $ENV{USERDOMAIN}\\$ENV{USERNAME}:read";
|
|
#####Raiseall.pl should grant access to these shares in the main build lab
|
|
if ( !$ENV{MAIN_BUILD_LAB_MACHINE} )
|
|
{
|
|
for my $ID ( @releaseAccess )
|
|
{
|
|
$cmdLine .= " /grant $ID:read";
|
|
}
|
|
}
|
|
&comlib::ExecuteSystem( $cmdLine );
|
|
}
|
|
|
|
|
|
my @hashTable = &comlib::ParseTable( $theGroup, $lang, $buildArch, $buildType );
|
|
|
|
for my $line( @hashTable )
|
|
{
|
|
my $from = "$releaseResDir\\$line->{SourceDir}";
|
|
my $to = "$groupShareRootDir{$theGroup}\\$line->{DestDir}";
|
|
|
|
if( uc($line->{DestDir}) eq "IFS" || uc($line->{DestDir}) eq "HAL" || uc($line->{DestDir}) eq "PDK")
|
|
{
|
|
$copyFlag = "/yei";
|
|
}
|
|
else
|
|
{
|
|
$copyFlag = "/ydei";
|
|
}
|
|
my $tmpfile = &comlib::CreateExcludeFile( $line->{ExcludeDir} );
|
|
&comlib::ExecuteSystem( "xcopy $copyFlag /EXCLUDE:$tmpfile $from $to" );
|
|
}
|
|
}
|
|
return 1;
|
|
|
|
}
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub PostCopy
|
|
{
|
|
if( @validSkus )
|
|
{
|
|
#####Call cdimage
|
|
local $ENV{_ntpostbld}=$releaseResDir;
|
|
local $ENV{_ntpostbld_bak}=$ENV{_ntpostbld};
|
|
local $ENV{_BuildArch}=$buildArch;
|
|
local $ENV{_BuildType}=$buildType;
|
|
$ENV{dont_modify_ntpostbld} =1;
|
|
if( lc($buildArch) eq "x86" )
|
|
{
|
|
$ENV{x86}=1;
|
|
$ENV{386}=1;
|
|
$ENV{ia64}="";
|
|
$ENV{amd64}="";
|
|
}
|
|
elsif ( lc($buildArch) eq "amd64" )
|
|
{
|
|
$ENV{x86}="";
|
|
$ENV{386}="";
|
|
$ENV{ia64}="";
|
|
$ENV{amd64}=1;
|
|
}
|
|
elsif ( lc($buildArch) eq "ia64" )
|
|
{
|
|
$ENV{x86}="";
|
|
$ENV{386}="";
|
|
$ENV{ia64}=1;
|
|
$ENV{amd64}="";
|
|
}
|
|
|
|
logmsg( "set %_ntpostbld% = [$ENV{_ntpostbld}]");
|
|
logmsg( "set %_ntpostbld_bak% = [$ENV{_ntpostbld_bak}]");
|
|
logmsg( "Set x86 = [$ENV{x86}]" );
|
|
logmsg( "Set 386 = [$ENV{386}]" );
|
|
logmsg( "Set ia64 = [$ENV{ia64}]" );
|
|
logmsg( "Set amd64 = [$ENV{amd64}]" );
|
|
logmsg( "Set dont_modify_ntpostbld = [$ENV{dont_modify_ntpostbld}]" );
|
|
|
|
return 0 if (!&comlib::ExecuteSystem( "$ENV{RazzleToolPath}\\postbuildscripts\\cdimage.cmd -l:$lang -d:release" ) );
|
|
|
|
return 0 if (!&comlib::ExecuteSystem( "$ENV{RazzleToolPath}\\postbuildscripts\\makeprocd2 -l:$lang -d:release" ) );
|
|
|
|
#####Call filechk
|
|
return 0 if( !&comlib::ExecuteSystem( "perl $ENV{RazzleToolPath}\\postbuildscripts\\filechk.pl -l:$lang") );
|
|
|
|
return 0 if( !&comlib::ExecuteSystem( "$ENV{RazzleToolPath}\\postbuildscripts\\HashBuild.cmd srvrelhash -l:$lang"));
|
|
}
|
|
else
|
|
{
|
|
logmsg( "Skip cdimage.cmd and filechk.pl for MUI release" );
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub DeletePublicShare
|
|
{
|
|
#####use system for not logging the error message if the share is does not exist.
|
|
if( !system( "net share $latestReleaseShareName >nul 2>nul") )
|
|
{
|
|
return 0 if( !&comlib::ExecuteSystem( "net share $latestReleaseShareName /d /y" ) );
|
|
}
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub CreatePublicShare
|
|
{
|
|
my ( $cmdLine );
|
|
|
|
if( system( "net share $latestReleaseShareName >nul 2>nul") )
|
|
{
|
|
$cmdLine = "rmtshare \\\\$ENV{computerName}\\$latestReleaseShareName=$releaseResDir";
|
|
$cmdLine .= " /grant $ENV{USERDOMAIN}\\$ENV{USERNAME}:read";
|
|
#####Raiseall.pl should grant access to these shares in the main build lab
|
|
if ( !$ENV{MAIN_BUILD_LAB_MACHINE} )
|
|
{
|
|
for my $ID ( @releaseAccess )
|
|
{
|
|
$cmdLine .= " /grant $ID:read";
|
|
}
|
|
}
|
|
return 0 if( !&comlib::ExecuteSystem( $cmdLine ) );
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub VerifyDiskSpace
|
|
{
|
|
my ($availDiskSpace, $retry, $reqSpace ) = (0, 0, 1000000000);
|
|
my $tmpFile = "$ENV{_ntdrive}\\freeSize";
|
|
my @freeSize;
|
|
|
|
$reqSpace *= $freeSpaceReq;
|
|
|
|
while( $retry < 2)
|
|
{
|
|
system( "cd /d $releaseDrive:\&freedisk>$tmpFile&cd /d $ENV{_ntdrive}" );
|
|
@freeSize = &comlib::ReadFile( $tmpFile );
|
|
unlink( $tmpFile );
|
|
if( ($freeSize[0] - $reqSpace) > 0 )
|
|
{
|
|
logmsg( "Available disk space [$freeSize[0]], delete builds is not required." );
|
|
return 1;
|
|
}
|
|
my ( $cmdLine ) = "$ENV{RazzleToolPath}\\postbuildscripts\\deletebuild.cmd AUTO \/l $lang \/a $buildArch$buildType \/f $freeSpaceReq \/k $numBuildToKeep";
|
|
return 1 if( &comlib::ExecuteSystem( $cmdLine ) );
|
|
++$retry;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#-----------------------------------------------------------------------------
|
|
sub PurgeOldCdimage
|
|
{
|
|
for my $theDir ( @validSkus )
|
|
{
|
|
my $curDir = "$releaseResDir\\$theDir";
|
|
if( -e $curDir )
|
|
{
|
|
logmsg( "Purging old cdimage [$curDir]" );
|
|
&comlib::ExecuteSystem( "rd /s /q $curDir" );
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
sub VirusScanSummary
|
|
{
|
|
#####Open/read directory where is the location of virus scan output file
|
|
if( !opendir( LOGDIR, $ENV{temp} ) )
|
|
{
|
|
errmsg( "Fail to open directory [$ENV{temp}] for read.");
|
|
return 0;
|
|
}
|
|
my @allFiles = readdir( LOGDIR );
|
|
closedir(LOGDIR);
|
|
|
|
####Loop through all the virus scan output file to have summary
|
|
my $totFileScanned=0;
|
|
my $totVirusFound=0;
|
|
my $totInfectedFiles=0;
|
|
my @allLines;
|
|
my @errorFiles=();
|
|
for my $theFile ( @allFiles )
|
|
{
|
|
next if( $theFile !~ /(.+)(.scan)/ );
|
|
|
|
@allLines = &comlib::ReadFile( "$ENV{temp}\\$theFile" );
|
|
|
|
for my $theLine ( @allLines )
|
|
{
|
|
if( $theLine =~ /(Total Files Scanned:)\s+(\d+)/ )
|
|
{
|
|
$totFileScanned += $2;
|
|
next;
|
|
}
|
|
if( $theLine =~ /(Total Viruses Found:)\s+(\d+)/ )
|
|
{
|
|
$totVirusFound += $2;
|
|
push( @errorFiles, $theFile ) if( $2 );
|
|
next;
|
|
}
|
|
if( $theLine =~ /(Total Infected Files Found:)\s+(\d+)/ )
|
|
{
|
|
$totInfectedFiles += $2;
|
|
push( @errorFiles, $theFile ) if( $2) ;
|
|
next;
|
|
}
|
|
}
|
|
}
|
|
my $msgStr;
|
|
$msgStr = sprintf( "%-27.27s[%6d]", "Total Files Scanned:", $totFileScanned );
|
|
logmsg( $msgStr );
|
|
$msgStr = sprintf( "%-27.27s[%6d]", "Total Viruses Found:", $totVirusFound );
|
|
logmsg( $msgStr );
|
|
$msgStr = sprintf( "%-27.27s[%6d]", "Total Infected Files Found:", $totInfectedFiles );
|
|
logmsg( $msgStr );
|
|
if( $totVirusFound || $totInfectedFiles )
|
|
{
|
|
errmsg( "Found Virus, please check the following files:[@errorFiles]" );
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
#-----------------------------------------------------------------------------
|
|
1;
|