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.
534 lines
20 KiB
534 lines
20 KiB
#-----------------------------------------------------------------//
|
|
# Script: access.pm
|
|
#
|
|
# (c) 2002 Microsoft Corporation. All rights reserved.
|
|
#
|
|
# decomposes the remote test boot installation run.
|
|
#
|
|
# Version: <2.31> 06/11/2002 : Serguei Kouzmine
|
|
#
|
|
#-----------------------------------------------------------------//
|
|
|
|
use strict;
|
|
package access;
|
|
|
|
no strict 'refs';
|
|
use vars (qw());
|
|
use WMIFE qw($verbose);
|
|
use Logmsg;
|
|
use RemoteProc;
|
|
use AutoBoottest;
|
|
use vars (qw(
|
|
$_ReleaseShare
|
|
$_ToolShare
|
|
$ToolShare
|
|
$_BuildArch
|
|
$_BldSku
|
|
$ForceReboot
|
|
$Lang
|
|
$MasterMachine
|
|
$MasterUserAccount
|
|
$MasterUserPassword
|
|
$SourcePath
|
|
$TargetDrive
|
|
$TargetMachine
|
|
$TargetSystemDrive
|
|
$TargetSystemRoot
|
|
$TestUserAccount
|
|
$TestUserPassword
|
|
$Unattend
|
|
$SourceIsDFS
|
|
));
|
|
|
|
use Carp;
|
|
|
|
|
|
|
|
my $USAGE =<<USAGE;
|
|
Usage:
|
|
&access::boottest(
|
|
\$TargetMachine, # Target Machine name
|
|
\$Lang, # language
|
|
\$SourcePath, # Source Path in the form:
|
|
\\\\<BUILDMACHINE>\\<RELEASE>\\<LANG>\\<BLDNAME>\\<SKU>\\<ARCH>
|
|
or e.g.
|
|
\\\\winbuilds\\release\\main\\usa\\latest.tst\\x86fre\\srv\\i386
|
|
\$BuildArch # architecture
|
|
\$BldSku # sku
|
|
\$ToolShare # share to tools \\<BUILDMACHINE>\<TOOLS SHARE NAME>
|
|
# leave this parameter undef in the case you use DFS
|
|
\$TestUserAccount, # test user (leave empty for DFS install)
|
|
\$TestUserPassword, # logon data (leave empty for DFS install)
|
|
\$ForceReboot, # reboot switch (1: reboot, 0: don’t)
|
|
\$SourceIsDFS # this argument must be FALSE unless
|
|
# source bits accessible through DFS (see also above)
|
|
);
|
|
USAGE
|
|
|
|
my $ToolPath = "NEWTOOLS";
|
|
my $TIMEOUT = 5;
|
|
my $UNATTEND = q(unattend.$_BuildArch.$_BldSku.txt);
|
|
my $RELEASE = "RELEASE";
|
|
my $TOOLSHARE = "BOOTTEST";
|
|
my $PROCESS = "winnt32.exe";
|
|
my $SERVICE = "SCHEDULE";
|
|
my $TARGETDRIVE = "D:";
|
|
my $TOOLDRIVE = "T:";
|
|
my $RELEASEDRIVE = "Y:";
|
|
|
|
my $VERSION = "2.2";
|
|
my $DEBUG = 0;
|
|
|
|
my $DELAY1 = 120;
|
|
my $DELAY2 = 60;
|
|
my $DELAY3 = 240;
|
|
my $DELAY4 = 10;
|
|
my $REPEAT = 30;
|
|
my $SYSTEMROOT = $ENV{"SYSTEMROOT"};
|
|
my $SYSTEMDRIVE = $ENV{"SYSTEMDRIVE"};
|
|
|
|
$ENV{"SCRIPT_NAME"} = "access.pm";
|
|
my $Results;
|
|
my @answ = ();
|
|
my @Credentials = ("*");
|
|
# start ...
|
|
|
|
$TargetMachine = undef;
|
|
$SourcePath = undef;
|
|
$TestUserAccount = undef;
|
|
$TestUserPassword = undef;
|
|
my $ToolsMachine = undef;
|
|
|
|
# Usage:
|
|
# &access::boottest(
|
|
# $TargetMachine, # Target Machine name
|
|
# $SourcePath, # path to winnt32.exe, including DFS part name, e.g.
|
|
#
|
|
# \\winbuilds\release\main\usa\latest.tst\x86fre\srv\i386
|
|
# (everything winnt32.exe copies must be in this location or directories therein)
|
|
#
|
|
# $BuildArch # architecture
|
|
# $BldSku # sku
|
|
# $ToolShare # share to tools is ignored in DFS case
|
|
# $TestUserAccount, # test user is ignored in DFS case
|
|
# $TestUserPassword, # logon data is ignored in DFS case
|
|
# $Reboot # reboot switch (1: reboot, 0: don’t)
|
|
# $SourceIsDFS # this argument must be TRUE)
|
|
#
|
|
#
|
|
#
|
|
|
|
sub boottest{
|
|
|
|
$TargetMachine = $_[0]; #$machinename
|
|
$SourcePath = $_[1]; #path to winnt32
|
|
$Lang = $_[2]; #lang
|
|
$_BuildArch = $_[3]; #Architechture
|
|
$_BldSku = $_[4]; #SKU
|
|
$_ToolShare = $_[5]; #path to tools
|
|
$Unattend = $_[6]; #unattend file name
|
|
$TestUserAccount = $_[7]; #user for release/tools
|
|
$TestUserPassword = $_[8]; #pass for user
|
|
$ForceReboot = $_[9]; #Force a Reboot <=> DFS install
|
|
|
|
($MasterMachine, $_ReleaseShare) = $SourcePath =~ /\\\\([^\\]*)\\([^\\]*)\\.*/;
|
|
($ToolsMachine, $ToolShare) = $_ToolShare =~ /\\\\([^\\]*)\\(.*)/;
|
|
|
|
$TargetDrive = $TARGETDRIVE;
|
|
$WMIFE::DEBUG = $DEBUG;
|
|
$WMIFE::TIMEOUT = $TIMEOUT;
|
|
$MasterUserPassword = undef;
|
|
$MasterUserAccount = $ENV{"USERDOMAIN"}."\\".$ENV{"USERNAME"};
|
|
$Unattend = $UNATTEND;
|
|
$Unattend =~ s/\$(\w+)\b/${$1}/eg;
|
|
|
|
die &WMIFE::pPpPinfo($USAGE) unless defined($TargetMachine);
|
|
|
|
@Credentials = ($MasterUserAccount, $MasterUserPassword)
|
|
unless !$MasterUserPassword;
|
|
|
|
my $Process = $PROCESS;
|
|
my $Service = $SERVICE;
|
|
my $ToolDrive = $TOOLDRIVE;
|
|
my $ReleaseDrive = $RELEASEDRIVE;
|
|
my $sRootKey = $WMIFE::sRootKey;
|
|
my $sBootTestDataSubKey = $WMIFE::sBootTestDataSubKey;
|
|
my $sLogonUserDataSubKey = $WMIFE::sLogonUserDataSubKey;
|
|
|
|
my $answ;
|
|
|
|
$TargetSystemRoot = $SYSTEMROOT;
|
|
$TargetSystemDrive = $SYSTEMDRIVE;
|
|
|
|
$Results = &WMIFE::ExecQuery($TargetMachine, # interactive session
|
|
qq(SELECT * FROM Win32_operatingsystem),
|
|
[qw(WindowsDirectory)],
|
|
@Credentials);
|
|
$TargetSystemRoot = $Results->[0]->{"WindowsDirectory"};
|
|
$TargetSystemDrive = $TargetSystemRoot;
|
|
$TargetSystemDrive =~ s/\\.*$//g;
|
|
#=============================================================================
|
|
|
|
if ($SourceIsDFS){
|
|
$ForceReboot = 0;
|
|
$DEBUG = 1;
|
|
my $hereIsStep;
|
|
$hereIsStep =<<PROMPT4PASS;
|
|
%SYSTEMROOT%\\SYSTEM32\\CSCRIPT.EXE %RAZZLETOOLPATH%\\POSTBUILDSCRIPTS\\wsh.iexplore.dialog.input.wsf
|
|
rem Prompt the user for the password
|
|
PROMPT4PASS
|
|
$DEBUG and
|
|
print $hereIsStep, "\n";
|
|
my $userData = &WMIFE::BackTick($hereIsStep);
|
|
my ($TestUserAccount) = $userData =~ m/BT_U\s+=\s+(.+)/g;
|
|
my ($TestUserPassword) = $userData =~ m/BT_P\s+=\s+(.+)/g;
|
|
$DEBUG and
|
|
print STDERR $TestUserAccount,
|
|
"\n",
|
|
$TestUserPassword,
|
|
"\n";
|
|
my $ToolsToCopy = join(" ", qw(
|
|
%RAZZLETOOLPATH%\\POSTBUILDSCRIPTS\\rx.wsf
|
|
%RAZZLETOOLPATH%\\POSTBUILDSCRIPTS\\NTCrypt.exe
|
|
)) ;
|
|
$hereIsStep= <<COPYTOOLS;
|
|
REM Creating the directory for tools
|
|
md \\\\%TARGETMACHINE%\\%TARGETSYSTREMDRIVE%\\%TOOLPATH%
|
|
REM copy everything to the tagret machine
|
|
for %. in (%TOOLSTOCOPY%) do @(echo %. & copy %. \\\\%TARGETMACHINE%\\%TARGETSYSTREMDRIVE%\\%TOOLPATH%)
|
|
|
|
COPYTOOLS
|
|
|
|
my $_TargetSystemDrive = $TargetSystemDrive;
|
|
$_TargetSystemDrive =~ s/\:/\$/;
|
|
$hereIsStep =~ s/\%TARGETMACHINE\%/$TargetMachine/g;
|
|
$hereIsStep =~ s/\%TARGETSYSTREMDRIVE\%/$_TargetSystemDrive/g;
|
|
$hereIsStep =~ s/\%TOOLPATH\%/$ToolPath/g;
|
|
|
|
$hereIsStep =~ s/\%TOOLSTOCOPY\%/$ToolsToCopy/g;
|
|
|
|
print STDERR $hereIsStep, "\n";
|
|
print &WMIFE::BackTick($hereIsStep);
|
|
|
|
} # $SourceIsDFS
|
|
$answ = undef;
|
|
if ($DEBUG){
|
|
&logmsg( "Check pending jobs at \\\\$TargetMachine");
|
|
|
|
my $TasksPath = $TargetSystemRoot ."\\\\TASKS\\\\";
|
|
$TasksPath =~ s/^\w:/\\/g;
|
|
|
|
$Results = &WMIFE::ExecQuery($TargetMachine,
|
|
# task files
|
|
"SELECT * FROM cim_DataFile WHERE Drive = \"$TargetSystemDrive\" AND Path = \"$TasksPath\" AND FileType Like \"Task Scheduler\%\"",
|
|
[qw(FileName FileType Path)],
|
|
@Credentials);
|
|
|
|
foreach my $Result (@$Results){
|
|
$DEBUG and
|
|
map {&WMIFE::FormatDebugMsg($_, $Result->{$_})}
|
|
keys (%$Result);
|
|
}
|
|
@answ = ();
|
|
map {push @answ, $_->{"FileName"}} @$Results;
|
|
@answ = grep {/\S/} @answ;
|
|
|
|
$answ = \@answ;
|
|
}
|
|
|
|
if ($ForceReboot){
|
|
|
|
&logmsg("Write $sLogonUserDataSubKey on \\\\$TargetMachine");
|
|
&WMIFE::supplyRegData($TargetMachine,
|
|
"SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\WINLOGON",
|
|
{
|
|
"DefaultUserName" => $TestUserAccount,
|
|
"DefaultDomainName" => $TargetMachine,
|
|
"DefaultPassword" => $TestUserPassword,
|
|
"AutoAdminLogon" => "1",
|
|
"ForceAutoLogon" => "1",
|
|
"PasswordExpiryWarning" => "0",
|
|
},
|
|
{},
|
|
1);
|
|
|
|
&logmsg("Reboot \\\\$TargetMachine to have $TestUserAccount logged");
|
|
&WMIFE::ObjectExecMethod("Win32_Process",
|
|
"Create",
|
|
$TargetMachine,
|
|
"CommandLine",
|
|
"$TargetSystemRoot\\SYSTEM32\\cmd.exe /c USE $RELEASEDRIVE /D&net USE $TOOLDRIVE /D&net USE $TOOLDRIVE $_ToolShare $TestUserPassword /u:$MasterMachine\\$TestUserAccount&$TOOLDRIVE\\autologon.exe /MIGRATE&shutdown.exe /r /m \\\\$TargetMachine /f /t 0",
|
|
@Credentials);
|
|
|
|
#Wait for system to shutdown & come back up
|
|
AutoBoottest::WaitOnProcess($TargetMachine, "csrss.exe", -1, "", "");
|
|
if(!AutoBoottest::WaitForProcess($TargetMachine, "services.exe", $DELAY3, "", "")){
|
|
errmsg("Fatal error: $TargetMachine may have not restarted correctly");
|
|
exit(1);
|
|
}
|
|
sleep($DELAY4); #give it another 10 secs just in case
|
|
}
|
|
|
|
|
|
|
|
&logmsg("Write $sBootTestDataSubKey on \\\\$TargetMachine");
|
|
|
|
&WMIFE::supplyRegData($TargetMachine,
|
|
"SOFTWARE\\MICROSOFT\\BOOTTEST",
|
|
{"LANG" => uc($Lang),
|
|
"_BldSku" => uc($_BldSku),
|
|
"_BldDrive" => $TargetDrive,
|
|
"Unattend" => $Unattend,
|
|
"SourcePath" => $SourcePath,
|
|
"ToolsPath" => $_ToolShare,
|
|
"_BuildArch" => $_BuildArch},
|
|
{"COMPUTERNAME" => $ENV{"COMPUTERNAME"}},
|
|
1);
|
|
|
|
&logmsg("Schedule task for $TargetMachine\\\\$TestUserAccount");
|
|
my $stLabel = join("_", $Lang,
|
|
$_BldSku ) ;
|
|
my $res = &wrScheduTsk(
|
|
$stLabel,
|
|
$TargetMachine,
|
|
$TargetSystemRoot,
|
|
$ToolDrive,
|
|
$ReleaseDrive,
|
|
$ToolShare,
|
|
$ToolsMachine,
|
|
$_ReleaseShare,
|
|
$MasterMachine,
|
|
$TestUserAccount,
|
|
$TestUserPassword,
|
|
$SourceIsDFS);
|
|
if("0" eq $res){
|
|
errmsg("wrScheduTsk failed");
|
|
exit(1);
|
|
}
|
|
|
|
#Wait on scheduled task for 1 min - if failed - kill it & try again
|
|
if( ! AutoBoottest::WaitForTask($TargetMachine, $res, $DELAY2)){
|
|
qx("schtasks /DELETE /S:$TargetMachine /U:$TestUserAccount /P:$TestUserPassword /TN:$res");
|
|
&wrScheduTsk($stLabel,
|
|
$TargetMachine,
|
|
$TargetSystemRoot,
|
|
$ToolDrive,
|
|
$ReleaseDrive,
|
|
$ToolShare,
|
|
$ToolsMachine,
|
|
$_ReleaseShare,
|
|
$MasterMachine,
|
|
$TestUserAccount,
|
|
$TestUserPassword,
|
|
$SourceIsDFS);
|
|
if(0 == $res){
|
|
errmsg("wrScheduTsk failed");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
#We'll just die if it doesn't work this time
|
|
if( ! AutoBoottest::WaitForTask($TargetMachine, $res, $DELAY2)){
|
|
errmsg("Error starting task $res on $TargetMachine - exiting");
|
|
exit(1);
|
|
}
|
|
|
|
|
|
&logmsg("Wait while $TargetMachine's drives are formatted");
|
|
# beside checking for format.com it is possible to catch the moment drive is
|
|
# being formatted
|
|
#&wtDriveReady($TargetMachine, @Credentials);
|
|
if((!AutoBoottest::WaitForProcess($TargetMachine, "format.com", 180, "", ""))
|
|
||
|
|
(!AutoBoottest::WaitOnProcess($TargetMachine, "format.com", 300, "", "")))
|
|
{
|
|
errmsg("Fatal error: $TargetMachine may not have formatted drives correctly");
|
|
exit(1);
|
|
}
|
|
|
|
|
|
&logmsg("Verify $Process in \%TARGET\% \(TASK LIST\)");
|
|
&AutoBoottest::WaitForProcess($TargetMachine, $Process, $DELAY2, "", "");
|
|
$answ = &WMIFE::IsRunning("Win32_Process",
|
|
$Process,
|
|
"CommandLine",
|
|
["ProcessId", "Name" , "CommandLine"],
|
|
$TargetMachine);
|
|
|
|
&logmsg("@$answ");
|
|
|
|
1;
|
|
}
|
|
|
|
sub wtDriveReady{
|
|
|
|
my ($TargetMachine, $MasterUserAccount, $MasterUserPassword) = @_;
|
|
my $repeat = 0;
|
|
|
|
$DEBUG and
|
|
print STDERR "BVT target drive on $TargetMachine:\n\n";
|
|
my $Caption = "";
|
|
|
|
while (1){
|
|
|
|
$#$Results = -1;
|
|
$Results =
|
|
&WMIFE::ExecQuery($TargetMachine, # interactive session
|
|
qq(SELECT * FROM win32_logicaldisk Where DriveType = 3 and FileSystem IS NULL),
|
|
[qw(VolumeName Caption DriveType FileSystem Description)],
|
|
$MasterUserAccount, $MasterUserPassword);
|
|
last if scalar(@$Results);
|
|
print ".";
|
|
print "failed $REPEAT attempts\n" and last unless $repeat++< $REPEAT;
|
|
sleep(1);
|
|
}
|
|
$repeat = 0;
|
|
while (1){
|
|
|
|
$#$Results = -1;
|
|
$Results =
|
|
&WMIFE::ExecQuery($TargetMachine, # interactive session
|
|
qq(SELECT * FROM win32_logicaldisk Where DriveType = 3 and FileSystem IS NULL),
|
|
[qw(VolumeName Caption DriveType FileSystem Description)],
|
|
$MasterUserAccount, $MasterUserPassword);
|
|
last unless scalar(@$Results);
|
|
print ".";
|
|
print "failed $REPEAT attempts\n" and last unless $repeat++< $REPEAT;
|
|
|
|
|
|
foreach my $Result (@$Results){
|
|
|
|
$DEBUG and
|
|
map {&WMIFE::FormatDebugMsg($_, $Result->{$_})} keys (%$Result);
|
|
$Caption = $Result->{"Caption"} if $Result->{"Caption"};
|
|
}
|
|
|
|
sleep(1);
|
|
|
|
}
|
|
}
|
|
|
|
sub wrScheduTsk{
|
|
|
|
my (
|
|
$stLabel,
|
|
$TargetMachine,
|
|
$TargetSystemRoot,
|
|
$ToolDrive,
|
|
$ReleaseDrive,
|
|
$ToolShare,
|
|
$ToolsMachine,
|
|
$_ReleaseShare,
|
|
$MasterMachine,
|
|
$TestUserAccount,
|
|
$TestUserPassword,
|
|
$LocalInstall
|
|
) = @_;
|
|
# $TargetSystemRoot is lest in argument list for it could be needed
|
|
my $Schtasks = "schtasks.exe";
|
|
|
|
my $TaskName = join "_", $stLabel, time;
|
|
my $STFilever = qx("ver");
|
|
my $StartTime = ( $STFilever =~ /2600/ )? "\%HH\%:\%MM\%:\%SS\%": "\%HH\%:\%MM\%";
|
|
# "secs" not needed for TS running in build 36XX.
|
|
|
|
my $AtCommandTemplate = (!$LocalInstall)?
|
|
qq(%SCHTASKS% /create /s %TARGET% /tn %TASKNAME% /u %TARGET%\\%USER% /p %PASSWORD% /sc once /st $StartTime /sd %mm%/%dd%/%yyyy% /tr cmd.exe /C NET USE %TOOLDISK% /D&NET USE %TOOLDISK% %TOOLSHARE% %PASSWORD% /U:%TOOLSMACHINE%\\%USER%&CSCRIPT.EXE %TOOLDISK%\\rx.wsf /from:\\\\%BLDMACHINE%\\%RELEASESHARE% /usedfs")
|
|
:
|
|
qq(%SCHTASKS% /create /s %TARGET% /tn %TASKNAME% /u %TARGET%\\%USER% /p %PASSWORD% /sc once /st $StartTime /sd %mm%/%dd%/%yyyy% /tr "%SYSTEMROOT%\\SYSTEM32\\cmd.exe /C NET USE %TOOLDISK% /D&NET USE %RELEASEDISK% /D&NET USE %TOOLDISK% %TOOLSHARE% %PASSWORD% /U:%MASTER%\\%USER%&NET USE %RELEASEDISK% \\\\%BLDMACHINE%\\%RELEASESHARE% %PASSWORD% /U:%MASTER%\\%USER%&CSCRIPT.EXE %TOOLDISK%\\rx.wsf /from:\\\\%MASTER%\\%RELEASESHARE%");
|
|
# WARNING: Length of the command line argument should not exceed 255 characters
|
|
|
|
$DEBUG and
|
|
print STDERR "AT Command template:\n\"$AtCommandTemplate\"\n";
|
|
|
|
my $ScheduleTime = &WMIFE::ScheduleTime($DELAY1);
|
|
my $marker = ["HH" , "MM", "SS", "mm", "dd", "yyyy"];
|
|
|
|
my $AtCommand = $AtCommandTemplate;
|
|
|
|
$AtCommand =~ s/\%TASKNAME\%/$TaskName/g;
|
|
$AtCommand =~ s/\%SCHTASKS\%/$Schtasks/g;
|
|
$AtCommand =~ s/\%SYSTEMROOT\%/$TargetSystemRoot/g;
|
|
$AtCommand =~ s/\%SYSTEMDRIVE\%/$TargetSystemDrive/g;
|
|
$AtCommand =~ s/\%ToolPath\%/$ToolPath/g;
|
|
|
|
$AtCommand =~ s/\%TARGET\%/$TargetMachine/g;
|
|
$AtCommand =~ s/\%MASTER\%/$MasterMachine/g;
|
|
|
|
$AtCommand =~ s/\%TOOLDISK\%/$ToolDrive/g;
|
|
$AtCommand =~ s/\%TOOLSMACHINE\%/$ToolsMachine/g;
|
|
# we hardcode here that TOOLSHARE is allocated on the TOOLSMACHINE
|
|
$AtCommand =~ s/\%TOOLSHARE\%/\\\\$ToolsMachine\\$ToolShare/g;
|
|
|
|
$AtCommand =~ s/\%RELEASEDISK\%/$ReleaseDrive/g;
|
|
$AtCommand =~ s/\%RELEASESHARE\%/$_ReleaseShare/g;
|
|
|
|
|
|
$AtCommand =~ s/\%USER\%/$TestUserAccount/g;
|
|
$AtCommand =~ s/\%PASSWORD\%/$TestUserPassword/g;
|
|
|
|
map {$AtCommand =~ s/\%$marker->[$_]\%/$ScheduleTime->[$_]/g;} (0..$#$marker);
|
|
|
|
for my $i (qx("net use")){
|
|
# win32_share ?
|
|
($i =~ /\w*\s*(\\\\$TargetMachine\\\w*\$+).*/) &&
|
|
$DEBUG ? print `net use $1 /delete /y 2>&1` :
|
|
`net use $1 /delete /y 2>&1`;
|
|
}
|
|
|
|
$DEBUG and
|
|
print STDERR "$AtCommand\n";
|
|
system($AtCommand);
|
|
$TaskName;
|
|
|
|
}
|
|
|
|
|
|
1;
|
|
__END__
|
|
|
|
|
|
|
|
=head1 Scheduled autoboottest control flow.
|
|
|
|
=head2 RELEASE is accessed from MASTER SHARE
|
|
|
|
MASTER: create TARGET->TESTUSER
|
|
MASTER: create MASTER->TESTUSER
|
|
MASTER: create MASTER->TOOLSHARE
|
|
MASTER: share MASTER->RELEASESHARE for MASTER->TESTUSER
|
|
MASTER: WRITE TARGET->REGISTRY (logon data)
|
|
MASTER: reboot TARGET
|
|
MASTER: WRITE TARGET->REGISTRY (encrypted password)
|
|
MASTER: schedule TASK for TARGET->TESTUSER
|
|
MASTER: wait for TASK steps to be passed
|
|
|
|
|
|
TARGET: execute TASK SCRIPT from MASTER->TOOLSHARE
|
|
TASK SCRIPT: FORMAT TARGET->TESTDRIVE
|
|
TASK SCRIPT: HANDLE TARGET->BOOT OPTIONS
|
|
TASK SCRIPT: start INSTALLATION from MASTER->RELEASESHARE
|
|
|
|
=head2 RELEASE is accessed through DFS
|
|
|
|
MASTER: create TARGET->SYSTEMDRIVE->TOOLDIR
|
|
MASTER: copy scripts and binaries to the TARGET
|
|
MASTER: WRITE TARGET->REGISTRY (build info)
|
|
MASTER: prompt user for password and encrypt it
|
|
MASTER: WRITE TARGET->REGISTRY (encrypted password)
|
|
MASTER: schedule TASK for TARGET->NT AUTHORITY\SYSTEM
|
|
MASTER: wait for TASK steps to be passed
|
|
|
|
TARGET: execute TASK SCRIPT from TARGET->SYSTEMDRIVE->TOOLDIR
|
|
TASK SCRIPT: DECRYPT MASTER password and get access to DFSSHARE
|
|
TASK SCRIPT: FORMAT TARGET->TESTDRIVE
|
|
TASK SCRIPT: HANDLE TARGET->BOOT OPTIONS
|
|
TASK SCRIPT: start INSTALLATION from DFSSHARE
|
|
|
|
=head2 Note. This is a bare bones implementation.
|
|
Room for structural improvement is:
|
|
* providing the Test Machine status reflection in
|
|
REGISTRY and/or FILESYSTEM areas visible from Build Machine.
|
|
* manipulate settings to record the winnt32.exe messages to ease
|
|
break analysis
|
|
|