895 lines
25 KiB
Perl
895 lines
25 KiB
Perl
# ---------------------------------------------------------------------------
|
|
# Script: autoboottest.pl
|
|
#
|
|
# (c) 2000 Microsoft Corporation. All rights reserved.
|
|
#
|
|
# Purpose: This script is an example of a perl script in the NT postbuild
|
|
# environment.
|
|
#
|
|
# Version: <1.00> (<mm/dd/yyyy>) : (<your alias>) <Purpose>
|
|
# <1.01> (<mm/dd/yyyy>) : (<your alias>) <Purpose>
|
|
#---------------------------------------------------------------------
|
|
|
|
# Set Package
|
|
# <Set your package name of your perl module>
|
|
package autoboottest;
|
|
|
|
# Set the script name
|
|
# <Set your script name>
|
|
$ENV{script_name} = 'autoboottest.pl';
|
|
|
|
# Set version
|
|
# <Set the version of your script>
|
|
$VERSION = '1.00';
|
|
|
|
# Set required perl version
|
|
# <Set the version of perl that your script requires>
|
|
require 5.003;
|
|
|
|
# Use section
|
|
use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
|
|
use lib $ENV{RAZZLETOOLPATH};
|
|
use GetParams;
|
|
use LocalEnvEx;
|
|
use GetIniSetting;
|
|
use cksku;
|
|
use Logmsg;
|
|
use strict;
|
|
no strict 'vars';
|
|
# <Add any perl modules that you will be using for this script>
|
|
|
|
# Require section
|
|
require Exporter;
|
|
# <Add any perl pl files that you will be using>
|
|
|
|
# Global variable section
|
|
# <Add any global variables here using my to preserve namespace>
|
|
|
|
$selectedsku = undef;
|
|
|
|
(@BuildArchs, @BuildTypes, @JoinDomain) = ();
|
|
|
|
($FirstBuildMachine, @ReleaseServers, $ReleaseServers, $ReleaseRemote, $BootTestMachines,
|
|
$BuildNumber, $AutoRaise)=();
|
|
|
|
($BuildBranch, $BuildArchs, $BuildTypes)=(
|
|
$ENV{_BuildBranch}, $ENV{_BuildArch}, $ENV{_BuildType}
|
|
);
|
|
|
|
# Assumption: BootTestDrive defined in Boot Test Machine remote.
|
|
# Please reference BootTestDriveVarName in bootinit.cmd
|
|
|
|
($BootTestDriveVar, $PostBootTest, $UnAttend, $OpShellFolder) = (
|
|
"BootTestDrive", "PostBootTest", "unattend.txt", "OpShellFolder.pl"
|
|
);
|
|
|
|
sub Main {
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
# Begin Main code section
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
# Return when you want to exit on error
|
|
# <Implement your code here>
|
|
my (%skus)=();
|
|
|
|
my (@BootTestMachines, $BuildName, $sku, $PostBootTestFile ) = ();
|
|
|
|
|
|
# BUGBUG - need to remove if we turn on outside main
|
|
# if not defined MAIN_BUILD_LAB_MACHINE goto End
|
|
|
|
return if (!exists $ENV{MAIN_BUILD_LAB_MACHINE});
|
|
|
|
&initial;
|
|
|
|
# for $BuildBranch, we can not change branch, because currently template limitation
|
|
# for $lang. we can not change language, because currently template limitation
|
|
|
|
# Initial GetIniSetting
|
|
unless ( &GetIniSetting::CheckIniFile ) {
|
|
errmsg( "Failed to find ini file ..." );
|
|
return;
|
|
}
|
|
|
|
# for @BuildArchs, now is only execute one time, because template limitation
|
|
|
|
|
|
for $BuildArch (@BuildArchs) {
|
|
|
|
$ENV{_BuildArch} = $BuildArch;
|
|
%skus = &cksku::GetSkus($lang, $BuildArch);
|
|
|
|
# for @BuildTypes, now is only execute one time, because template limitation
|
|
for $BuildType (@BuildTypes) {
|
|
$ENV{_BuildType} = $BuildType;
|
|
|
|
# Get Build Name
|
|
$BuildName = &GetLatestBuildName;
|
|
next if (!defined $BuildName);
|
|
$BuildNumber = (split(/\./, $BuildName))[0];
|
|
|
|
# Get build share
|
|
$BuildShare = &GetBuildShare($BuildName);
|
|
|
|
# Get Release Server
|
|
@ReleaseServers = &GetReleaseServers;
|
|
$ReleaseRemote = &GetReleaseRemote;
|
|
|
|
# Get BuildMachine
|
|
$FirstBuildMachine = &GetFirstBuildMachine($BuildBranch, $BuildArch, $BuildType);
|
|
|
|
# Get Account
|
|
@JoinDomain = split(/\s+/, &GetAccount);
|
|
|
|
# Get AutoRaise
|
|
$AutoRaise = &GetAutoRaise($BuildArch, $BuildType);
|
|
|
|
for $sku (reverse(keys %skus)) {
|
|
next if (defined ($selectedsku)
|
|
&& $sku ne $selectedsku);
|
|
# Get Boot Test Machines
|
|
@BootTestMachines = &GetBootTestMachine( $BuildArch, $BuildType, $sku );
|
|
$BootTestMachines = join(" ", map({$_ . "1"} @BootTestMachines));
|
|
|
|
for $BootTestMachine (@BootTestMachines) {
|
|
|
|
# Show the boot test machine we working on
|
|
logmsg("Start to install build on $BootTestMachine....");
|
|
# Write PostBootTestScript
|
|
$PostBootTestFile = "$ENV{temp}\\${PostBootTest}_${BootTestMachine}.cmd";
|
|
&WritePostBootTestScript($PostBootTestFile, $BootTestMachines, $FirstBuildMachine, $BuildArch, $BuildType, @ReleaseServers );
|
|
&StartBootTest($BuildArch, $BuildShare, $sku, $PostBootTestFile, $BootTestMachine);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
# End Main code section
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
}
|
|
|
|
# <Implement your subs here>
|
|
|
|
sub initial {
|
|
|
|
@BuildArchs = splitcolon( $BuildArchs ); # x86 or amd64 or ia64
|
|
@BuildTypes = splitcolon( $BuildTypes ); # fre or chk
|
|
|
|
}
|
|
|
|
sub StartBootTest {
|
|
my ($BuildArch, $BuildShare, $sku, $PostBootTestFile, $BootTestMachine) = @_;
|
|
|
|
my $BootCmd;
|
|
|
|
# For some reason there is no environment variable for i386
|
|
my $TargetArch = ($BuildArch eq "x86")?"i386":$BuildArch;
|
|
my $UnattendFile = "$ENV{tmp}\\$UnAttend";
|
|
my $OpShellFolderFile = "$ENV{RazzleToolPath}\\postbuildscripts\\$OpShellFolder";
|
|
|
|
# Compose Boot Command
|
|
$BootCmd = &ComposeBootCmd($TargetArch, $BuildShare, $sku);
|
|
|
|
# Make the Unattend file
|
|
&WriteUnattendFile($UnattendFile, $BootTestMachine, $BuildBranch);
|
|
errmsg "Unable to create answer file." if (!-e $UnattendFile);
|
|
|
|
# Issue Commands
|
|
&IssueBootTestCommands($BuildArch, $BootTestMachine, $UnattendFile, $PostBootTestFile, $OpShellFolderFile, $BootCmd);
|
|
}
|
|
|
|
#
|
|
# ComposeBootCmd($TargetArch, $BuildShare, $sku)
|
|
#
|
|
# purpose: Generate the boot command. Such as "winnt32 ....", so we can call issue command
|
|
#
|
|
sub ComposeBootCmd {
|
|
|
|
my ($TargetArch, $BuildShare, $sku) = @_;
|
|
|
|
my $BinSource = "$BuildShare\\$sku\\$TargetArch";
|
|
my $UnattendFile = "/Unattend:\%$BootTestDriveVar\%\\tools\\$UnAttend";
|
|
my $CmdOpt;
|
|
if ($AutoRaise) {
|
|
$CmdOpt = "/cmd:\"\%$BootTestDriveVar\%\\tools\\perl\\bin\\perl.exe " .
|
|
"\%$BootTestDriveVar\%\\tools\\OpShellFolder.pl " .
|
|
"CopyFileTo Startup \%$BootTestDriveVar\%\\tools\\PostBootTest.cmd\"";
|
|
}
|
|
|
|
# Set the boot command to issue
|
|
# Have to remove winnt32 when testing on MP machines
|
|
return "$BinSource\\winnt32.exe /#bvt:nosymbols /tempdrive:\%$BootTestDriveVar\% $UnattendFile $CmdOpt";
|
|
|
|
}
|
|
|
|
#
|
|
# WriteUnattendFile($UnattendFile, $BootTestMachine, $Branch)
|
|
#
|
|
# purpose: Generate Unattend File
|
|
#
|
|
sub WriteUnattendFile {
|
|
|
|
my($UnattendFile, $BootTestMachine, $Branch) = @_;
|
|
|
|
open(F, ">$UnattendFile");
|
|
|
|
print F <<UnattendFile;
|
|
|
|
[data]
|
|
Unattendedinstall=yes
|
|
msdosinitiated="0"
|
|
|
|
[Unattended]
|
|
UnattendMode = fullUnattended
|
|
OemSkipEula = yes
|
|
TargetPath=test
|
|
Filesystem=LeaveAlone
|
|
NtUpgrade=no
|
|
ConfirmHardware = No
|
|
Repartition = No
|
|
|
|
[branding]
|
|
brandieusingunattended = yes
|
|
|
|
[Proxy]
|
|
Proxy_Enable = 1
|
|
Use_Same_Proxy = 1
|
|
HTTP_Proxy_Server = http://itgproxy:80
|
|
Secure_Proxy_Server = http://itgproxy:80
|
|
|
|
[GuiUnattended]
|
|
AutoLogon =Yes
|
|
AutoLogonCount = 1
|
|
TimeZone=04
|
|
AdminPassword=*
|
|
oemskipregional =1
|
|
oemskipwelcome = 1
|
|
|
|
[UserData]
|
|
FullName="$Branch"
|
|
OrgName="Microsoft"
|
|
ComputerName="${BootTestMachine}1"
|
|
ProductID="\$\{P_roductID\}"
|
|
|
|
[LicenseFilePrintData]
|
|
AutoMode = "PerServer"
|
|
AutoUsers = "50"
|
|
|
|
[Display]
|
|
BitsPerPel=0x10
|
|
XResolution=0x400
|
|
YResolution=0x300
|
|
VRefresh=0x3C
|
|
Flags=0x0
|
|
AutoConfirm=0x1
|
|
|
|
[RegionalSettings]
|
|
LanguageGroup = 1, 7, 8, 9, 10, 11, 12, 13
|
|
|
|
[Networking]
|
|
InstallDefaultComponents=Yes
|
|
|
|
[Identification]
|
|
JoinDomain=$JoinDomain[0]
|
|
DomainAdmin=\${BT_U}
|
|
DomainAdminPassword=\${BT_P}
|
|
|
|
[SetupData]
|
|
OsLoadOptionsVar="/fastdetect /debug /baudrate=115200"
|
|
|
|
UnattendFile
|
|
|
|
close(F);
|
|
|
|
}
|
|
|
|
#
|
|
# IssueBootTestCommands($buildarch, $BootTestMachine, $UnattendFile, $PostBootTestFile, $OpShellFolderFile, $BootCmd)
|
|
#
|
|
# purpose: According the paramters and issue below commands to Boot Test machine
|
|
# Phase 1: Format the Boot test drive
|
|
# Phase 2: Prepare reference files (such as unattend.txt, opshellfolder.pl, postboottest.cmd)
|
|
# Phase 3: Process Boot file (boot.ini or boot.nvr or nvram.sav)
|
|
# Phase 4: Run winnt32
|
|
#
|
|
sub IssueBootTestCommands {
|
|
|
|
# ------------ Data definition
|
|
my ($buildarch, $BootTestMachine, $UnattendFile, $PostBootTestFile, $OpShellFolderFile, $BootCmd) = @_;
|
|
|
|
my $cmd;
|
|
|
|
# Set the tools copy command
|
|
my $SourceToolDir="\\\\$ENV{ComputerName}\\$ENV{RazzleToolPath}\\$buildarch";
|
|
my $TargetToolDir="\^\%$BootTestDriveVar\^\%\\tools";
|
|
|
|
# Construct the UNC
|
|
$UnattendFile = "\\\\$ENV{ComputerName}\\$UnattendFile";
|
|
$PostBootTestFile = "\\\\$ENV{ComputerName}\\$PostBootTestFile";
|
|
$OpShellFolderFile = "\\\\$ENV{ComputerName}\\$OpShellFolderFile";
|
|
|
|
# replace <drv>: with <drv>$
|
|
$UnattendFile =~ s/\\(\w)\:\\/\\$1\$\\/;
|
|
$SourceToolDir =~ s/\\(\w)\:\\/\\$1\$\\/;
|
|
$PostBootTestFile =~ s/\\(\w)\:\\/\\$1\$\\/;
|
|
$OpShellFolderFile =~ s/\\(\w)\:\\/\\$1\$\\/;
|
|
|
|
# Phase 1: Format the Boot test drive (details see below the 'code' part)
|
|
#
|
|
# Phase 2: Prepare reference files (such as unattend.txt, opshellfolder.pl, postboottest.cmd)
|
|
my @Phase2 = &FormStrToArray( <<Phase2);
|
|
|
|
if not exist $TargetToolDir md $TargetToolDir
|
|
start /w /min cmd /c copy /y $PostBootTestFile $TargetToolDir\\${PostBootTest}.cmd.temp
|
|
start /w /min cmd /c copy /y $UnattendFile $TargetToolDir\\${UnAttend}.temp
|
|
start /min cmd /c xcopy /fdice $SourceToolDir $TargetToolDir
|
|
start /min cmd /c copy /y $OpShellFolderFile $TargetToolDir\\$OpShellFolder
|
|
\^\^\%systemdrive\^\^\%\\simple_perl\\perl \^\^\%systemdrive\^\^\%\\simple_perl\\ParseSys.pl $TargetToolDir\\${PostBootTest}.cmd.temp $TargetToolDir\\${PostBootTest}.cmd
|
|
\^\^\%systemdrive\^\^\%\\simple_perl\\perl \^\^\%systemdrive\^\^\%\\simple_perl\\ParseSys.pl $TargetToolDir\\${UnAttend}.temp $TargetToolDir\\$UnAttend
|
|
|
|
Phase2
|
|
|
|
# Phase 3: Process Boot file (boot.ini or boot.nvr)
|
|
my @Phase3;
|
|
|
|
my $BootFile;
|
|
|
|
$BootFile="boot.ini" if (lc$buildarch eq "x86");
|
|
$BootFile="boot.ini" if (lc$buildarch eq "amd64");
|
|
$BootFile="boot.nvr" if (lc$buildarch eq "ia64");
|
|
|
|
# Phase 3a: Save off the boot file for intel machines
|
|
@Phase3 = &FormStrToArray( <<Phase3a);
|
|
|
|
if exist c:\\${BootFile} attrib -s -r -h c:\\${BootFile}
|
|
if exist c:\\${BootFile}.sav attrib -s -r -h c:\\${BootFile}.sav
|
|
if exist c:\\${BootFile}.sav copy /y c:\\${BootFile}.sav c:\\${BootFile}
|
|
if /i "$BootFile" equ "Boot.ini" if exist c:\\${BootFile} attrib +s +r +h c:\\${BootFile}
|
|
if exist c:\\${BootFile}.sav attrib +s +r +h c:\\${BootFile}.sav
|
|
|
|
Phase3a
|
|
|
|
# Phase 4: Run winnt32
|
|
@Phase4 = &FormStrToArray( <<Phase4);
|
|
|
|
start /min $BootCmd
|
|
|
|
Phase4
|
|
|
|
# ------------ Code
|
|
|
|
# Prepare the Phase 1's answer file
|
|
open(F, ">$ENV{tmp}\\format_${lang}.txt");
|
|
print F "Format \%$BootTestDriveVar\% /X /FS:NTFS /Q\n";
|
|
print F "Y\n\n\n";
|
|
close(F);
|
|
|
|
|
|
# Phase 1: Format the Boot test drive
|
|
&MyRemoteCommand($BootTestMachine, "BootTestRemote", "Echo Beginning boot test");
|
|
&MyRemoteCommand($BootTestMachine, "BootTestRemote", "$ENV{tmp}\\format_${lang}.txt", 1);
|
|
sleep 45;
|
|
|
|
# Phase 2, Phase 3:
|
|
for $cmd ( @Phase2, @Phase3) {
|
|
&MyRemoteCommand($BootTestMachine, "BootTestRemote", $cmd);
|
|
}
|
|
|
|
# Phase 4: start setup
|
|
for $cmd ( @Phase4) {
|
|
&MyRemoteCommand($BootTestMachine, "BootTestRemote", $cmd);
|
|
}
|
|
|
|
}
|
|
|
|
#
|
|
# FormStrToArray(@strs)
|
|
# Parameters:
|
|
# @strs: multi-line string " This is a text.\n This is another line\n\t\tAnd, have tabs"
|
|
#
|
|
# purpose: Seperate the multi-line string into an array and format it
|
|
#
|
|
sub FormStrToArray {
|
|
my (@strs)=@_;
|
|
my (@result, $str, $line);
|
|
|
|
for $str (@strs) {
|
|
for $line (split(/\n/, $str)) {
|
|
chomp $str;
|
|
$line=~s/^\s+$//;
|
|
$line=~s/\t/ /g;
|
|
push @result, $line;
|
|
}
|
|
}
|
|
return @result;
|
|
}
|
|
|
|
#
|
|
# WritePostBootTestScript($postboottestfile, $boottestlist, $myprimary, $buildarch, $buildtype, @ReleaseServers)
|
|
# Parameters:
|
|
# $postboottestfile: such as "postboottest.cmd"
|
|
# $boottestlist: such as "i32bt0011 i32bt0021"
|
|
# $myprimary: such as "i32fre"
|
|
# $buildarch: such as "x86"
|
|
# $buildtype: such as "fre"
|
|
# @ReleaseServers: such as ("intblds10", "intblds11" )
|
|
#
|
|
# purpose: According the parameters, generate postboottestfile
|
|
#
|
|
sub WritePostBootTestScript {
|
|
# Write a script on the fly to use on the boot test machine. The reason
|
|
# This needs to be done on the fly is so that we can use sources and
|
|
# and environment variables only available on the build machines.
|
|
|
|
my ($PostBootTestFile, $BootTestList, $MyPrimary, $buildarch, $buildtype, @ReleaseServers ) = @_;
|
|
|
|
my $langopt = ((defined $lang)&&(lc$lang ne "usa"))?"-l:$lang":"";
|
|
|
|
my $ReleaseServers = join(" ", @ReleaseServers);
|
|
|
|
`del /f $PostBootTestFile` if (-e $PostBootTestFile);
|
|
|
|
open(F, ">$PostBootTestFile");
|
|
|
|
print F <<PostBootTestFile;
|
|
|
|
\@echo off
|
|
|
|
if DEFINED _echo echo on
|
|
if DEFINED verbose echo on
|
|
|
|
REM This script will kick off stress after a boot test is complete.
|
|
REM In addition, it will make a marker file indicating that boot tests have passed
|
|
REM for the main build lab only so that we can raise to BVT automatically.
|
|
|
|
REM Note that we will have to delete the marker files in postbuild before making them here.
|
|
REM We need release to also have a list of files to match against based on boottestmachines.txt
|
|
|
|
REM Provide usage.
|
|
for \%\%a in (./ .- .) do if \".\%1.\" == \"\%\%a?.\" goto Usage
|
|
|
|
REM Write the done file to be used by release
|
|
set $BootTestDriveVar=\$\{$BootTestDriveVar\}
|
|
set ${BootTestDriveVar}Share=\%$BootTestDriveVar:~0,1\%\$
|
|
set LOGFILE=\%$BootTestDriveVar\%\\tools\\BootTest.log
|
|
|
|
REM Don't create a "booted" remote any longer! It's a security hole!
|
|
REM call :LogMe "Create a remote for raiseall.pl"
|
|
REM start \%BootTestDrive\%\\tools\\remote /S \"cmd.exe\" Booted
|
|
|
|
REM If no wait, start raiseall with quality bvt
|
|
if not defined Wait (
|
|
REM BUGBUG Wait 27 minutes before we try to raise the build to give release time to complete.
|
|
sleep 1620
|
|
call :LogMe "Raiseall to BVT on all release servers"
|
|
for \%\%a in ($ReleaseServers) do (
|
|
net use \\\\\%\%a /u:\${BT_U} \${BT_P}
|
|
if errorlevel 1 (
|
|
call :LogMe "Error - \%\%a can not connect"
|
|
) else (
|
|
call :LogMe "Start Raiseall..."
|
|
echo start cmd /c perl ^^^\%\%RazzleToolPath^^^\%\%\\postbuildscripts\\raiseall.pl -n:$BuildNumber -q:bvt -a:$buildarch -t:$buildtype $langopt | \%$BootTestDriveVar\%\\tools\\remote /c \%\%a $ReleaseRemote /L 1>nul
|
|
REM 300
|
|
\%BootTestDrive\%\\tools\\sleep 3
|
|
net use \\\\\%\%a /d
|
|
if errorlevel 1 call :LogMe "Error - \%\%a can not disconnect"
|
|
)
|
|
)
|
|
)
|
|
|
|
call :LogMe "Move PostBootTest.cmd to desktop"
|
|
\%$BootTestDriveVar\%\\tools\\perl\\bin\\perl \%$BootTestDriveVar\%\\tools\\OpShellFolder.pl CopyFileTo Desktop \%$BootTestDriveVar\%\\tools\\postboottest.cmd
|
|
\%$BootTestDriveVar\%\\tools\\perl\\bin\\perl \%$BootTestDriveVar\%\\tools\\OpShellFolder.pl Delfile Startup postboottest.cmd
|
|
|
|
call :LogMe "PostBootTest.cmd finished."
|
|
goto :exit
|
|
|
|
:logme
|
|
echo \%1
|
|
echo \%1>>\%LOGFILE\%
|
|
|
|
goto :EOF
|
|
|
|
:exit
|
|
endlocal
|
|
|
|
PostBootTestFile
|
|
|
|
close(F);
|
|
|
|
logmsg "Failed to create postboottest.cmd" if (!-e $PostBootTestFile);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
#################################### Reusable functions
|
|
|
|
#
|
|
# GetFirstBuildMachine($branch, $arch, $type)
|
|
#
|
|
# purpose: Get first primary build machine or first secondary build machine
|
|
# if not defined primary from buildmachines.txt
|
|
#
|
|
sub GetFirstBuildMachine {
|
|
|
|
# ($order, $branch, $arch, $type) = ("primary", @_);
|
|
my $searchpattern = join(",", @_);
|
|
my @BuildMachines;
|
|
my ($machinename, $firstbuildmachine, $line);
|
|
|
|
open(F, "$ENV{RazzleToolPath}\\BuildMachines.txt");
|
|
@BuildMachines = <F>;
|
|
close(F);
|
|
|
|
for $line (@BuildMachines) {
|
|
$machinename = (split(/\,/, $line))[0];
|
|
if ($line =~ /$searchpattern/i) {
|
|
return $machinename if ($line =~ /primary/i);
|
|
$firstbuildmachine=$machinename if (!defined $firstbuildmachine);
|
|
}
|
|
}
|
|
errmsg "Failed to find a build machine." if(!defined $firstbuildmachine);
|
|
return $firstbuildmachine;
|
|
|
|
}
|
|
|
|
|
|
#
|
|
# GetFirstBuildMachine($branch, $arch, $type)
|
|
#
|
|
# purpose: Get first primary build machine or first secondary build machine
|
|
# if not defined primary from buildmachines.txt
|
|
#
|
|
sub GetAccount {
|
|
my (@Request) = ("JoinDomain");
|
|
my( $JoinDomain ) = &GetIniSetting::GetSetting( @Request );
|
|
return $JoinDomain;
|
|
}
|
|
|
|
#
|
|
# GetBuildPath($buildname, [$compname], [$releaseshare])
|
|
#
|
|
# purpose: Get the fullpath share, so we can write file correctly. such as \\i32fre\release\jpn\1234 => \\i32fre\f$\release\jpn\1234
|
|
#
|
|
sub GetBuildPath {
|
|
my ($releaseshare) = @_;
|
|
my ($computername, $sharename, $misc, $sharepath);
|
|
|
|
|
|
# Get the computername, sharename, and remain paths
|
|
if ($releaseshare =~ /^\\\\([^\\]+)\\([^\\]+)/) {
|
|
($computername, $sharename, $misc) = ($1, $2, $');
|
|
} elsif ($releaseshare =~ /^([^\\]+)/) {
|
|
($computername, $sharename, $misc) = ($ENV{computername}, $1, $');
|
|
} else {
|
|
errmsg("Can not get correct build path ($releaseshare)");
|
|
return;
|
|
}
|
|
|
|
# Replace d: to d$ if applicable
|
|
$sharename =~ s/\:/\$/;
|
|
|
|
for my $line (`rmtshare \\\\$computername\\$sharename`) {
|
|
$sharepath=$1 if ($line =~ /^Path\s+(.+)$/);
|
|
}
|
|
|
|
if (!defined $sharepath) {
|
|
errmsg("Can not find the path of this share ($sharename)");
|
|
return;
|
|
}
|
|
|
|
# Remove d:\ to d: if applicable
|
|
$sharepath =~ s/\\$//;
|
|
# Replace d: to d$ if applicable
|
|
$sharepath =~ s/\:/\$/;
|
|
|
|
return "\\\\$computername\\$sharepath\\$misc";
|
|
|
|
}
|
|
|
|
|
|
#
|
|
# GetBuildShare($buildname, [$compname], [$releaseshare])
|
|
#
|
|
# purpose: Get build share from computer ($compname). Default is $ENV{computername
|
|
#
|
|
sub GetBuildShare {
|
|
|
|
my ($buildname, $compname, $releaseshare) = @_;
|
|
|
|
# This setting is misnamed as it is actually used as both the directory
|
|
# and share name
|
|
my (@Request) = ("AlternateReleaseDir");
|
|
my ($inirelease) = &GetIniSetting::GetSetting( @Request );
|
|
|
|
$compname = $ENV{computername} if (!defined $compname);
|
|
$releaseshare = $inirelease || 'release' if (!defined $releaseshare);
|
|
|
|
my $BuildShare = (lc$lang eq "usa")?"\\\\$compname\\$releaseshare\\$buildname":
|
|
"\\\\$compname\\$releaseshare\\$lang\\$buildname";
|
|
|
|
logmsg "No latest build to test - aborting." if (!defined $BuildShare);
|
|
logmsg "No latest build could find - aborting." if (!-e $BuildShare);
|
|
|
|
return $BuildShare;
|
|
|
|
}
|
|
|
|
#
|
|
# GetReleaseServers
|
|
#
|
|
# purpose: Get release server from ini file
|
|
#
|
|
sub GetReleaseServers {
|
|
|
|
my (@Request) = ("ReleaseServers", $ENV{_BuildArch} . $ENV{_BuildType});
|
|
my ($ReleaseServer) = &GetIniSetting::GetSetting( @Request );
|
|
|
|
my @ReleaseServers;
|
|
|
|
@Request = ("PrimaryReleaseServer");
|
|
@ReleaseServers = &GetIniSetting::GetSetting( @Request );
|
|
|
|
# Collect Release Servers to @ReleaseServers
|
|
# Avoid to include primary release server twice
|
|
#
|
|
# hardcode exclude ntburnlab08
|
|
push(@ReleaseServers,
|
|
grep {!(
|
|
# USA case
|
|
((lc$lang eq "usa") && (/ntburnlab08|intblds10/i)) ||
|
|
# Primary release server
|
|
((defined $ReleaseServers[0]) && (/\Q$ReleaseServers[0]\E/i)))
|
|
} split(/\s+/, $ReleaseServer)
|
|
);
|
|
|
|
errmsg "Could not find release servers to raise." if (!@ReleaseServers);
|
|
|
|
return @ReleaseServers;
|
|
|
|
}
|
|
|
|
sub GetReleaseRemote {
|
|
my (@Request) = ("AlternateReleaseRemote");
|
|
my( $ReleaseRemote ) = &GetIniSetting::GetSetting( @Request );
|
|
$ReleaseRemote = "release" if (!defined $ReleaseRemote);
|
|
return $ReleaseRemote;
|
|
}
|
|
|
|
#
|
|
# GetBootTestMachine($arch, $type, $sku)
|
|
#
|
|
# purpose: Get Boot Test Machine from ini file
|
|
#
|
|
sub GetBootTestMachine {
|
|
my ($arch, $type, $sku) = @_;
|
|
|
|
my (@Request) = ( "BootTestMachines", uc$arch . uc$type, $sku);
|
|
|
|
return split(/\s+/, &GetIniSetting::GetSetting( @Request ));
|
|
}
|
|
|
|
#
|
|
# GetLatestBuildName
|
|
#
|
|
# purpose: call getlatestrelease.cmd and handle its error
|
|
#
|
|
sub GetLatestBuildName {
|
|
|
|
my $buildname = `$ENV{RazzleToolPath}\\PostBuildScripts\\GetLatestRelease.cmd -l:$lang`;
|
|
|
|
chomp $buildname;
|
|
|
|
if ($buildname =~ /none/i) {
|
|
errmsg "No Binaries tree or latest release found - Aborting.";
|
|
return;
|
|
}
|
|
return $buildname;
|
|
|
|
}
|
|
|
|
|
|
#
|
|
# GetAutoRaise
|
|
#
|
|
# purpose: check the .ini file to see if we should try to auto raise or not
|
|
#
|
|
sub GetAutoRaise {
|
|
my ($arch, $type) = @_;
|
|
|
|
my (@Request) = ( "AutoRaise", uc$arch . uc$type);
|
|
|
|
return (&GetIniSetting::GetSetting( @Request ) =~ /true/i);
|
|
}
|
|
|
|
|
|
#
|
|
# MyRemoteCommand($Machine, $RemoteId, $cmd)
|
|
#
|
|
# purpose: Execute $cmd on remote console
|
|
#
|
|
sub MyRemoteCommand {
|
|
my ($Machine, $RemoteId, $cmd, $echotype) = @_;
|
|
|
|
$echotype = ($echotype eq "1")?"type":"echo";
|
|
|
|
$cmd = ($cmd=~/\S/)?"$echotype $cmd" : "${echotype}.";
|
|
|
|
# Make sure this gets logged properly
|
|
logmsg("Remote Command: '$cmd'");
|
|
|
|
# Wait 1 more second each time before each time we execute remote command
|
|
sleep 1;
|
|
|
|
return &MySystemCall("$cmd|remote /c $Machine $RemoteId >nul");
|
|
}
|
|
|
|
#
|
|
# MySystemCall($cmd)
|
|
#
|
|
# purpose: Execute $cmd thru system call
|
|
#
|
|
sub MySystemCall {
|
|
my ($cmd) = @_;
|
|
my $r = system($cmd);
|
|
$r >>= 8;
|
|
# Because remote command always return 4, we should ignore it.
|
|
if (($r)&&($r ne 4)&&($r ne 0)) {
|
|
errmsg "Failed ($r): $cmd";
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#
|
|
# splitcolon($str)
|
|
#
|
|
# purpose: split $str with delimiter ':' and return splited string
|
|
#
|
|
sub splitcolon {
|
|
return grep {/\w+/} split(/\:/, $_[0]);
|
|
}
|
|
|
|
##################################
|
|
|
|
sub ValidateParams {
|
|
#<Add your code for validating the parameters here>
|
|
}
|
|
|
|
# <Add your usage here>
|
|
sub Usage {
|
|
print <<USAGE;
|
|
Purpose of program
|
|
Usage: $0 [-l lang] [-y [pro\|ads\|ser\|dtd]]
|
|
-l Language
|
|
-y sku select
|
|
-? Displays usage
|
|
As of 02/13/01, the sku choice of [srv, pro] is available
|
|
for GER x86, and JPN x86 only.
|
|
Example:
|
|
$0 -l jpn
|
|
$0 -l:ger -y:pro
|
|
USAGE
|
|
}
|
|
|
|
sub GetParams {
|
|
# Step 1: Call pm getparams with specified arguments
|
|
&GetParams::getparams(@_);
|
|
|
|
# Step 2: Set the language into the enviroment
|
|
$ENV{lang}=$lang;
|
|
|
|
# Step 3: Call the usage if specified by /?
|
|
if ($HELP) {
|
|
&Usage();
|
|
exit 1;
|
|
}
|
|
}
|
|
|
|
# Cmd entry point for script.
|
|
if (eval("\$0 =~ /" . __PACKAGE__ . "\\.pl\$/i")) {
|
|
|
|
# Step 1: Parse the command line
|
|
# <run perl.exe GetParams.pm /? to get the complete usage for GetParams.pm>
|
|
&GetParams ('-o', 'l:y:', '-p', 'lang selectedsku', @ARGV);
|
|
|
|
# Include local environment extensions
|
|
&LocalEnvEx::localenvex('initialize');
|
|
|
|
# Set lang from the environment
|
|
$lang=$ENV{lang};
|
|
|
|
# Validate the option given as parameter.
|
|
&ValidateParams;
|
|
|
|
# Step 4: Call the main function
|
|
&autoboottest::Main();
|
|
|
|
# End local environment extensions.
|
|
&LocalEnvEx::localenvex('end');
|
|
}
|
|
|
|
# -------------------------------------------------------------------------------------------
|
|
# Script: autoboottest.pl
|
|
# Purpose: Template perl perl script for the NT postbuild environment
|
|
# SD Location: %sdxroot%\tools\postbuildscripts
|
|
#
|
|
# (1) Code section description:
|
|
# CmdMain - Developer code section. This is where your work gets done.
|
|
# <Implement your subs here> - Developer subs code section. This is where you write subs.
|
|
#
|
|
# (2) Reserved Variables -
|
|
# $ENV{HELP} - Flag that specifies usage.
|
|
# $ENV{lang} - The specified language. Defaults to USA.
|
|
# $ENV{logfile} - The path and filename of the logs file.
|
|
# $ENV{logfile_bak} - The path and filename of the logfile.
|
|
# $ENV{errfile} - The path and filename of the error file.
|
|
# $ENV{tmpfile} - The path and filename of the temp file.
|
|
# $ENV{errors} - The scripts errorlevel.
|
|
# $ENV{script_name} - The script name.
|
|
# $ENV{_NTPostBld} - Abstracts the language from the files path that
|
|
# postbuild operates on.
|
|
# $ENV{_NTPostBld_Bak} - Reserved support var.
|
|
# $ENV{_temp_bak} - Reserved support var.
|
|
#
|
|
# (3) Reserved Subs -
|
|
# Usage - Use this sub to discribe the scripts usage.
|
|
# ValidateParams - Use this sub to verify the parameters passed to the script.
|
|
#
|
|
# (4) Call other executables or command scripts by using:
|
|
# system "foo.exe";
|
|
# Note that the executable/script you're calling with system must return a
|
|
# non-zero value on errors to make the error checking mechanism work.
|
|
#
|
|
# Example
|
|
# if (system("perl.exe foo.pl -l $lang")){
|
|
# errmsg("perl.exe foo.pl -l $lang failed.");
|
|
# # If you need to terminate function's execution on this error
|
|
# goto End;
|
|
# }
|
|
#
|
|
# (5) Log non-error information by using:
|
|
# logmsg "<log message>";
|
|
# and log error information by using:
|
|
# errmsg "<error message>";
|
|
#
|
|
# (6) Have your changes reviewed by a member of the US build team (ntbusa) and
|
|
# by a member of the international build team (ntbintl).
|
|
#
|
|
# -------------------------------------------------------------------------------------------
|
|
|
|
=head1 NAME
|
|
B<mypackage> - What this package for
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
<An code example how to use>
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
<Use above example to describe this package>
|
|
|
|
=head1 INSTANCES
|
|
|
|
=head2 <myinstances>
|
|
|
|
<Description of myinstances>
|
|
|
|
=head1 METHODS
|
|
|
|
=head2 <mymathods>
|
|
|
|
<Description of mymathods>
|
|
|
|
=head1 SEE ALSO
|
|
|
|
<Some related package or None>
|
|
|
|
=head1 AUTHOR
|
|
<Your Name <your e-mail address>>
|
|
|
|
=cut
|
|
1;
|