windows-nt/Source/XPSP1/NT/tools/postbuildscripts/autoboottest.pl
2020-09-26 16:20:57 +08:00

895 lines
24 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;