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.
795 lines
25 KiB
795 lines
25 KiB
@perl -x "%~dpnx0" %*
|
|
@goto :EOF
|
|
#!perl
|
|
# ---------------------------------------------------------------------------
|
|
# Script: snapbin.pl
|
|
#
|
|
# (c) 2000 Microsoft Corporation. All rights reserved.
|
|
#
|
|
# Purpose: Snapshot US binaries tree to INTL.
|
|
#
|
|
# Version: 1.00 (05/10/2000) : (bensont) Snap the binaries tree
|
|
# 1.01 (05/10/2000) : (bensont) Create __BldInfo__usa__ file
|
|
# Version: 1.5 (03/12/2001) : (SERGUEIK) snapbin.pl => snapbin.cmd
|
|
#
|
|
#---------------------------------------------------------------------
|
|
|
|
# Set Package
|
|
package SnapBin;
|
|
|
|
# Set the script name
|
|
$ENV{script_name} = 'snapbin.cmd';
|
|
|
|
# Set version
|
|
$VERSION = '1.5';
|
|
|
|
require 5.003;
|
|
|
|
# Use section
|
|
use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
|
|
use lib $ENV{RAZZLETOOLPATH};
|
|
use PbuildEnv;
|
|
use ParseArgs;
|
|
use File::DosGlob qw(glob);
|
|
use GetParams;
|
|
use GetIniSetting;
|
|
use LocalEnvEx;
|
|
use Logmsg;
|
|
use strict;
|
|
|
|
use vars qw($lang) ;
|
|
|
|
use vars qw(
|
|
$NETBIOS_COMMAND
|
|
$NETVIEW
|
|
$ROBOCOPYLOG
|
|
$BUILD_NAME_MASK
|
|
$DEBUG);
|
|
|
|
use vars qw($BinarySnapServer
|
|
$BinarySnapServers
|
|
$BuildNum
|
|
$_BuildArch
|
|
$_BuildType
|
|
$_BuildBranch
|
|
$DFSAlternateBranchName
|
|
$_BuildTimeStamp
|
|
$_BldMarkerFile
|
|
$SourceTree
|
|
$SourceTreeChoice
|
|
$TargetTree
|
|
$RoboCopyCmd
|
|
$RoboCopyLog
|
|
$SnapList
|
|
$Incremental
|
|
);
|
|
|
|
use HashText;
|
|
use GetIniSetting;
|
|
|
|
my $NETBIOS_COMMAND = "NET VIEW computer";
|
|
|
|
my $BUILD_NAME_MASK = q(${BuildNum}.${_BuildArch}${_BuildType}.${_BuildBranch}.([0-9\-]+).${lang});
|
|
$BUILD_NAME_MASK =~ s/(\.|[^[]\\a-z0-9_{}()]+)/\Q$1\E/ig;
|
|
|
|
# Main Function
|
|
sub CmdMain {
|
|
|
|
unless ( &GetIniSetting::CheckIniFile ) {
|
|
exit errmsg( "Failed to find ini file ..." );
|
|
return;
|
|
}
|
|
$NETVIEW and &BinarySnapServer($BuildNum, $BinarySnapServer);
|
|
|
|
return unless &PrepareRoboCopyCmd;
|
|
&ExecuteRoboCopy;
|
|
&ReExRobocopy($RoboCopyCmd, $RoboCopyCmd, $SourceTree, $TargetTree);
|
|
my $dummy = ($NETVIEW) ? &GenerateBldInfo :
|
|
&CreateBldInfo($_BuildBranch);
|
|
&CountFiles;
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
# End CmdMain code section
|
|
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
|
|
}
|
|
|
|
sub CountFiles{
|
|
|
|
&logmsg("DESTINATION CHECK: ". &BackTick(<<COUNTING));
|
|
\@echo on
|
|
rem This is a comment
|
|
: note that delayed variable expansion seems not to work.
|
|
set WC=%RAZZLETOOLPATH%\\x86\\wc.exe
|
|
for /F %. in ('dir /a-d/b/s %_NTTREE% ^|%WC%') do @(echo %. files in ^%_NTTREE^% ^($_BuildArch^))
|
|
endlocal
|
|
COUNTING
|
|
1;
|
|
|
|
}
|
|
|
|
|
|
|
|
# &SourceTree
|
|
#
|
|
# net view the setver to see the available builds matching the
|
|
# $BuildNum, $_BuildArch, $_BuildType, $_BuildBranch
|
|
# implemented via the netBios pipe command
|
|
|
|
sub SourceTree{
|
|
|
|
# BinarySnapServer
|
|
# suggested by MikeR
|
|
no strict 'refs';
|
|
local ($BinarySnapServer, $BuildNum, $_BuildArch, $_BuildType, $_BuildBranch, $lang) = @_;
|
|
my $BUILD_NAME_MASK = $BUILD_NAME_MASK;
|
|
my $NETBIOS_COMMAND = $NETBIOS_COMMAND;
|
|
|
|
$NETBIOS_COMMAND =~ s/computer/$BinarySnapServer/;
|
|
$BUILD_NAME_MASK =~ s/\$\{?(\w+)\b\}?/${$1}/egi;
|
|
|
|
|
|
$DEBUG and print STDERR "netbios command: " , $NETBIOS_COMMAND, "\n";
|
|
$DEBUG and print STDERR "build name mask: ", $BUILD_NAME_MASK, "\n";
|
|
|
|
$DEBUG and print STDERR "available builds list:\n",
|
|
grep
|
|
{/$BUILD_NAME_MASK/i}
|
|
qx($NETBIOS_COMMAND);
|
|
|
|
[map
|
|
{$_->[0]}
|
|
map
|
|
{[split /\s+/]}
|
|
grep
|
|
{/$BUILD_NAME_MASK/i}
|
|
qx($NETBIOS_COMMAND)];
|
|
|
|
|
|
use strict 'refs';
|
|
}
|
|
|
|
|
|
# &_BuildTimeStamp
|
|
# filter out the time stamp part of the
|
|
# build name
|
|
|
|
sub _BuildTimeStamp{
|
|
no strict 'refs';
|
|
local ($_BuildTimeStamp, $BuildNum, $_BuildArch, $_BuildType, $_BuildBranch, $lang) = @_;
|
|
|
|
my $BUILD_NAME_MASK = $BUILD_NAME_MASK;
|
|
|
|
$BUILD_NAME_MASK =~ s/\$\{?(\w+)\b\}?/${$1}/egi;
|
|
|
|
map
|
|
{(s/$BUILD_NAME_MASK/$1/ig)}
|
|
@$_BuildTimeStamp;
|
|
|
|
$_BuildTimeStamp;
|
|
use strict 'refs';
|
|
}
|
|
|
|
|
|
sub BinarySnapServer{
|
|
|
|
#
|
|
# 1. Clean the variables inherited from the default execution environment:
|
|
# 2. Read the ini file to relate the build BinarySnapServer
|
|
# BinarySnapServer label
|
|
# suggested by MikeR
|
|
# 3. Given the BinarySnapServer and the %_BUILD...% parameters, determine
|
|
# the SourceTree and the _BuildTimeStamp.
|
|
#
|
|
#
|
|
|
|
my $_BuildTimeStamps, $SourceTreeChoice;
|
|
|
|
local $BuildNum = shift;
|
|
|
|
$SourceTree = undef;
|
|
|
|
$BinarySnapServer = shift;
|
|
|
|
$BinarySnapServers = [];
|
|
|
|
push @$BinarySnapServers, $BinarySnapServer if $BinarySnapServer;
|
|
|
|
scalar @$BinarySnapServers or
|
|
|
|
$BinarySnapServers = [split /\s/,
|
|
&GetIniSetting::GetSetting( "BinarySnapServers")];
|
|
|
|
$DEBUG and print STDERR "Binary Snap Servers: @$BinarySnapServers\n";
|
|
|
|
foreach my $BinarySnapServer (@$BinarySnapServers){
|
|
|
|
my @arguments = ($BuildNum,
|
|
$ENV{"_BuildArch"},
|
|
$ENV{"_BuildType"},
|
|
$ENV{"_BuildBranch"},
|
|
$ENV{"lang"});
|
|
|
|
|
|
$SourceTreeChoice = &SourceTree($BinarySnapServer, @arguments);
|
|
|
|
scalar @$SourceTreeChoice or next;
|
|
|
|
|
|
$SourceTree = "\\\\".$BinarySnapServer."\\".$SourceTreeChoice->[0];
|
|
$DEBUG and print STDERR "Source tree: " , $SourceTree, "\n";
|
|
|
|
$_BuildTimeStamps=&_BuildTimeStamp($SourceTreeChoice, @arguments);
|
|
|
|
scalar @$_BuildTimeStamps or next;
|
|
$_BuildTimeStamp = $_BuildTimeStamps->[0];
|
|
$DEBUG and print STDERR "Build time stamp: ", $_BuildTimeStamp, "\n";
|
|
|
|
# policy: pick the first available.
|
|
|
|
$DEBUG or return;
|
|
|
|
}
|
|
|
|
$DEBUG or errmsg("unable to determine snap parameters for ".
|
|
"binary Snap Servers: @$BinarySnapServers, ".
|
|
"build number: $BuildNum, ".
|
|
"giving up\n");
|
|
$DEBUG or exit (0);
|
|
|
|
&logmsg($NETBIOS_COMMAND);
|
|
&logmsg($BUILD_NAME_MASK);
|
|
|
|
}
|
|
|
|
|
|
# BackTick
|
|
# sample usage: &BackTick("dir");
|
|
# &BackTick(<<BLOCKBOUNDARY);
|
|
# ...cmd code...
|
|
# BLOCKBOUNDARY
|
|
# passes block of code to the cmd interpreter.
|
|
# lines are concatenated
|
|
# commened ones removed from the $cmd
|
|
# useful when the code is already
|
|
# developed and just needs to be inserted in place
|
|
# has limitations.
|
|
|
|
sub BackTick{
|
|
my ($cmd) = @_;
|
|
my $res = undef;
|
|
$cmd = join(" &", grep (!/^:|REM/i, ($cmd =~ /^(.+)/gm)));
|
|
$res=qx ($cmd);
|
|
$res;
|
|
}
|
|
|
|
|
|
|
|
# PrepareRoboCopyCmd
|
|
# Purpose : Reference $SourceTree, $TargetTree and file $SnapList to create Robocopy statement
|
|
#
|
|
# Input : none
|
|
# Output : 0 for fails, 1 for success
|
|
#
|
|
# Note : The Robocopy statement is stored in $RoboCopyCmd
|
|
sub PrepareRoboCopyCmd {
|
|
|
|
my ($Excludedirs, $Excludefiles, $Cmd, $OtherOptions)=();
|
|
my %snaplist;
|
|
my $machines;
|
|
$machines = "machines.txt" unless $machines;
|
|
my $Mirror = "/MIR";
|
|
-d $TargetTree or qx("md $TargetTree");
|
|
|
|
HashText::Read_Text_Hash(0, $SnapList, \%snaplist) if ((defined $SnapList) && ($SnapList ne '-'));
|
|
# HashText::Read_Text_Hash(1, $machines, \@machines);
|
|
|
|
# If <var> defined in string, evaluate by the order: global variable, environment variable. Report error if can not evaluate
|
|
|
|
$SourceTree =~ s/\<(\w+)\>/(eval "defined \$SnapBin::$1") ?
|
|
eval "\$SnapBin::$1":((exists $ENV{$1})?
|
|
$ENV{$1}:errmsg("Unable to eval $1 in $SourceTree; verify your razzle environment"))/ge;
|
|
$TargetTree =~ s/\<(\w+)\>/(eval "defined \$SnapBin::$1") ?
|
|
eval "\$SnapBin::$1":((exists $ENV{$1})?
|
|
$ENV{$1}:errmsg("Unable to eval $1 in $TargetTree; verify your razzle environment"))/ge;
|
|
|
|
# If source tree not exist
|
|
if (!-e $SourceTree) {
|
|
exit errmsg("Source Tree: \"$SourceTree\" not found.");
|
|
}
|
|
|
|
# Any above error should stop (Fail)
|
|
if ($ENV{errors} > 0) {return 0;}
|
|
|
|
# Parse the hash-hash table snaplist
|
|
foreach my $x_ (keys %snaplist) {
|
|
|
|
$_ = $snaplist{$x_}->{Type};
|
|
$Excludedirs .= ($x_=~/\\/)? "$SourceTree\\$x_ ": "$x_ " if /\bD\b/;
|
|
$Excludefiles .= ($x_=~/\\/)? "$SourceTree\\$x_ ": "$x_ " if (/\bF\b/);
|
|
}
|
|
|
|
$Excludefiles =
|
|
join " ", map {glob($_)} split(" ", $Excludefiles)
|
|
if ($Excludefiles);
|
|
|
|
$DEBUG and print STDERR "Exclude files:", $Excludefiles, "\n";
|
|
# Check if incremental run.
|
|
&ChkBabTree(\%snaplist) and exit;
|
|
# Create RoboCopyLogName as %logfile%.RoboCopy
|
|
$RoboCopyLog = `uniqfile $ENV{logfile}\.Robocopy`;
|
|
|
|
if (defined $Incremental) {
|
|
$Mirror = ""; # non-Mirror
|
|
$OtherOptions = "/XO"; # Exclude Older files
|
|
}
|
|
|
|
# Prepare the robocopy statement
|
|
$Cmd = "robocopy $Mirror /S /E $SourceTree $TargetTree $OtherOptions ";
|
|
$Cmd .= "/XD $Excludedirs " if ($Excludedirs ne '');
|
|
$Cmd .= "/XF $Excludefiles " if ($Excludefiles ne '');
|
|
|
|
$RoboCopyCmd = $Cmd . " /LOG+:$RoboCopyLog";
|
|
|
|
1;
|
|
}
|
|
|
|
# Verify that the snaplist.txt file does not contradict with
|
|
# the actual contents of the $TargetTree.
|
|
# usage:
|
|
# &ChkBabTree(\%snapList)
|
|
|
|
sub ChkBabTree{
|
|
|
|
my $snaplist = shift;
|
|
my @report = ();
|
|
|
|
my @children = grep {/\S/} split ("\n", qx ("dir /s/b/ad $TargetTree"));
|
|
my ($childrenkeys, %hashchildren, $subdir, $lastdir, );
|
|
$DEBUG and print STDERR "$TargetTree ",scalar (@children), " subdirs\n";
|
|
return 0 unless @children;
|
|
|
|
logmsg($TargetTree ." is not empty, possibly incremental run")
|
|
if scalar(@children);
|
|
|
|
map {$_ =~ s/\Q$TargetTree\E\\//} @children;
|
|
my %hashchildren = map {$_=>$_} @children;
|
|
|
|
$childrenkeys = \%hashchildren;
|
|
map {$childrenkeys->{$_} =~ s/^.*\\//} @children;
|
|
|
|
my @report = ();
|
|
foreach $subdir (@children){
|
|
my $lastdir = $childrenkeys->{$subdir};
|
|
push @report, sprintf("%-30s%-30s",$lastdir,$subdir) # and delete ($snaplist->{$lastdir})
|
|
if ($snaplist->{$lastdir}->{Type}=~/\bD\b$/) or () ;
|
|
}
|
|
foreach $lastdir (keys(%$snaplist)){
|
|
next unless $snaplist->{$lastdir}->{Type}=~/\bD\b/ && $lastdir=~/\\/;
|
|
my @subdir = grep {/\Q$lastdir\E/} @children;
|
|
push @report, sprintf("%-30s%-30s",$lastdir,$subdir[0]) if scalar (@subdir);
|
|
}
|
|
|
|
unshift @report, "snaplist.txt %_NTTREE%\n".
|
|
"-----------------------------------------------------"
|
|
and print join ("\n", @report ), "\n\n"
|
|
if scalar(@report);
|
|
|
|
scalar(@report);
|
|
0;
|
|
}
|
|
|
|
|
|
# ExecuteRoboCopy
|
|
# Purpose : Execute Robocopy Command ($RoboCopyCmd)
|
|
#
|
|
# Input : none
|
|
# Output : none
|
|
#
|
|
# Note : The serious error or fatal error will be logged.
|
|
sub ExecuteRoboCopy {
|
|
|
|
my $status_;
|
|
my $ROBOCOPY_ERROR = 8;
|
|
my $ROBOCOPY_SERIOS_ERROR = 16;
|
|
$RoboCopyCmd =~ s/\s+$//g;
|
|
logmsg("ROBOCOPY: $RoboCopyCmd\n");
|
|
logmsg("SOURCE: $SourceTree");
|
|
logmsg("TARGET: $TargetTree");
|
|
logmsg("LOGFILE: $RoboCopyLog");
|
|
$DEBUG and return;
|
|
$status_ = system($RoboCopyCmd) / 256;
|
|
|
|
# Determine the return value
|
|
if ($status_ > $ROBOCOPY_SERIOS_ERROR) {
|
|
exit errmsg("Fatal robocopy error.");
|
|
# Robocopy did not copy all files. This is either a usage error or an error due to
|
|
# insufficient access privileges on the source or destination directions.";
|
|
} elsif ($status_ > $ROBOCOPY_ERROR) {
|
|
errmsg("Robocopy failed to copy some files or directories.");
|
|
}
|
|
|
|
}
|
|
|
|
sub ReExRobocopy{
|
|
my @stack = @_;
|
|
my ($f_, @flist,$d_,$c_);
|
|
{
|
|
open (F, "$SnapList");
|
|
my $startParse = 0;
|
|
my @blist = ();
|
|
my $flist = ();
|
|
|
|
my @a = <F>;
|
|
foreach (@a){
|
|
next if /^;/;
|
|
if (/^Additional *$/){
|
|
$DEBUG and print "Additional directories:\n";
|
|
$startParse = 1;
|
|
}
|
|
$startParse=0 if ($startParse && $_ !~ /\S/);
|
|
if ($startParse && /\S/){
|
|
my @alist =
|
|
split(" ", $_);
|
|
if ($#alist>=2){
|
|
$f_ = undef;
|
|
$alist[0] =~ s/(.*)\\([^\\]+)/$1/g and $f_=$2 if $alist[1]=~/F/;
|
|
push @flist, $f_;
|
|
push @blist, $alist[0];
|
|
# &logmsg($alist[0]);
|
|
}
|
|
}
|
|
}
|
|
close(F);
|
|
foreach $c_ (0..$#blist){
|
|
$d_ = $blist[$c_];
|
|
$f_ = $flist[$c_];
|
|
$DEBUG and print STDERR "$d_\n";
|
|
($RoboCopyCmd, $RoboCopyLog, $SourceTree, $TargetTree) = @stack;
|
|
$RoboCopyCmd =~ s/\\\\.*$//g;
|
|
$RoboCopyLog =~ s|^.*(/LOG\+.*)$|$1.ADDED|g;
|
|
chomp $RoboCopyLog;
|
|
$SourceTree .= "\\$d_";
|
|
$TargetTree .= "\\$d_";
|
|
print "$SourceTree skipped\n" and next unless -d $SourceTree;
|
|
$RoboCopyCmd = join(" ", $RoboCopyCmd, $SourceTree, $TargetTree, $RoboCopyLog, $f_);
|
|
&ExecuteRoboCopy;
|
|
}
|
|
($RoboCopyCmd, $RoboCopyLog, $SourceTree, $TargetTree) = @stack;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
# ParseLogFile
|
|
# Purpose : Parse the log file which from argument and store to $ENV{logfile} with fully path
|
|
#
|
|
# Input : templogfile
|
|
# Output : none
|
|
#
|
|
# Note : The log file will contain all file get copied and extra files removed.
|
|
sub ParseLogFile {
|
|
|
|
my ($templogfile) = @_;
|
|
|
|
my ($type, $file, %slots, %fails, $path)=();
|
|
local *F;
|
|
|
|
# Read temp logfile
|
|
open(F, $templogfile) || return;
|
|
|
|
for(<F>) {
|
|
next if (/^\s*\-*\s*$/);
|
|
if (/^ROBOCOPY/) {(%slots,%fails)=(); next;}
|
|
|
|
chomp;
|
|
|
|
# If is error message, add to previous line
|
|
if (!/^\s/) {
|
|
if ($#{$fails{$type}} eq '-1') {
|
|
errmsg($_);
|
|
} else {
|
|
${$fails{$type}}[$#{$fails{$type}}] .= "\n$_";
|
|
}
|
|
next;
|
|
}
|
|
|
|
logmsg($_) if (defined $ROBOCOPYLOG);
|
|
|
|
# Parse information according the format of robocopy log
|
|
if (/^\s+(?:New Dir\s+)?(\d+)\s+([\w\:\\]+)$/) {
|
|
$path = $2;
|
|
next;
|
|
}
|
|
if (/^\s+((?:New File)|(?:Newer)|(?:\*EXTRA File)|(?:Older))\s+(\d+)\s+([\w\.]+)/) {
|
|
($type, $file) = ($1, $3);
|
|
|
|
((/100\%/)||(/\*EXTRA File/))?push(@{$slots{$type}}, $path . $file):push(@{$fails{$type}}, $path . $file);
|
|
}
|
|
}
|
|
close(F);
|
|
|
|
# Separate the log to success and fail
|
|
logmsg("\n\[Copy Success\]");
|
|
|
|
for $type (keys %slots) {
|
|
logmsg(" \[$type\]");
|
|
|
|
for $file (@{$slots{$type}}) {
|
|
logmsg("\t$file");
|
|
}
|
|
}
|
|
|
|
if (scalar(%fails) ne 0) {
|
|
errmsg("\n\[Copy Fails\]");
|
|
for $type (keys %fails) {
|
|
errmsg(" \[$type\]");
|
|
|
|
for $file (@{$fails{$type}}) {
|
|
errmsg("\t$file");
|
|
}
|
|
}
|
|
}
|
|
|
|
# If Robocopy log include into the logfile, remove the robocopy its logfile
|
|
if (defined $ROBOCOPYLOG) {
|
|
unlink($templogfile);
|
|
} else {
|
|
logmsg("CHECK ROBOCOPY LOGFILE: $templogfile");
|
|
}
|
|
}
|
|
|
|
# GenerateBldInfo
|
|
# A styripped down version of
|
|
# CreateBldInfo used when snapping from US release server
|
|
#
|
|
sub GenerateBldInfo{
|
|
|
|
$_BuildTimeStamp = "??????-????" unless $_BuildTimeStamp !~ /[\d-]/
|
|
&logmsg("BUILD ${BuildNum} ($_BuildArch) TIMESTAMP: $_BuildTimeStamp");
|
|
open(F, ">$_BldMarkerFile");
|
|
print F "$BuildNum,$_BuildTimeStamp";
|
|
close(F);
|
|
|
|
###Copy __blddate__ and __bldnum__ from US release server
|
|
map {qx("echo F|xcopy /V /F /R /Y $_ \%SDXROOT\%")}
|
|
glob ("${SourceTree}\\congeal_scripts\\__bld*__");
|
|
1;
|
|
|
|
}
|
|
# CreateBldInfo
|
|
# Purpose : Create build number and time stamps to $_BldMarkerFile
|
|
#
|
|
# Input : none
|
|
# Output : none
|
|
#
|
|
# Note : The file $_BldMarkerFile contain one line: '<Build Number>,<Time Stamp>'
|
|
#
|
|
# 3552.x86fre.main.010914-1644.SRV
|
|
|
|
sub CreateBldInfo {
|
|
|
|
local *F;
|
|
my @file;
|
|
my $BuildLabel = "$BuildNum, ??????-????";
|
|
if ($ENV{errors} > 0) {return 0;}
|
|
|
|
# Search the matched filename in $SourceTree's parent folder
|
|
|
|
@file = grep {/${BuildNum}\.\w+\.$_BuildBranch\.[0-9\-]+\.[A-Z]{3}/i}
|
|
glob("${SourceTree}\\..\\${BuildNum}.*.???");
|
|
|
|
if (defined $file[1]) {
|
|
errmsg("Non unique US marker file found.".
|
|
"\n Pick the first from the list:\n" .
|
|
join("\n", @file)."\n\n");
|
|
} elsif (!defined $file[0]) {
|
|
errmsg("Marker file not found. Please make sure the US path is valid:\n".
|
|
"${SourceTree}\\..\\${BuildNum}.*.???");
|
|
}
|
|
|
|
if ($file[0]!~/$BuildNum\.\w+\.\w+\.([\d|\-]+).[A-Z]{3}/i) {
|
|
errmsg("Marker Filename (".$file[0].") is incorrect format! Expected:\n".
|
|
"$BuildNum.$_BuildArch$_BuildType.$_BuildBranch.\$_BuildTimeStamp.???");
|
|
} else {
|
|
|
|
$_BuildTimeStamp = "$1";
|
|
}
|
|
|
|
&GenerateBldInfo();
|
|
|
|
|
|
}
|
|
|
|
sub ValidateParams {
|
|
|
|
!exists $ENV{RazzleToolPath} and
|
|
exit errmsg("Please run under razzle environment") ;
|
|
$BuildNum =~ /[^\d\.]/ and
|
|
exit errmsg("Build Number ($BuildNum) contains invalid characters");
|
|
$_BuildBranch = $ENV{"_BuildBranch"} unless $_BuildBranch;
|
|
$lang = "usa" unless $lang;
|
|
$DFSAlternateBranchName = &GetIniSetting::GetSettingEx( $_BuildBranch, $lang, "DFSAlternateBranchName");
|
|
|
|
$SourceTree = "\\\\ntdev\\release\\<_BuildBranch>\\usa\\<BuildNum>\\<_BuildArch><_BuildType>\\bin" unless $SourceTree;
|
|
$SourceTree = "\\\\ntdev\\release\\<DFSAlternateBranchName>\\usa\\<BuildNum>\\<_BuildArch><_BuildType>\\bin" if defined $DFSAlternateBranchName;
|
|
&dbgmsg("\$SourceTree=$SourceTree");
|
|
$TargetTree = $ENV{"_NTTREE"} unless $TargetTree;
|
|
$SnapList = $ENV{"RazzleToolPath"}."\\PostBuildScripts\\SnapList.txt" unless $SnapList;
|
|
$_BldMarkerFile = $ENV{"_NTROOT"}."\\__BldInfo__usa__" unless $_BldMarkerFile;
|
|
$_BuildArch = $ENV{"_BuildArch"} unless $_BuildArch;
|
|
$RoboCopyLog = ".Robocopy" unless $RoboCopyLog;
|
|
1;
|
|
}
|
|
|
|
sub Usage {
|
|
my $self = $0;
|
|
$self =~ s/^.+\\([^\\]+)$/$1/g;
|
|
print <<USAGE;
|
|
$self - Snap Tree from US to INTL
|
|
============================================================================
|
|
Usage: $self -n buildnum [-s SourceTree] [-t TargetTree] [-f SnapList]
|
|
[-y BuildBranch] [-B bldinfo] [-L] [-i] [-d]
|
|
-n Build Number : The Build Number you snapshot
|
|
-s Source Tree : Source Tree
|
|
-t Target Tree : Target Tree
|
|
-f SnapList : A snaplist file contain which files or dirs excluded
|
|
-y BuildBrahcn : Branch to snap the build from. Default %_BuildBranch%
|
|
-B bldinfo : A bldinfo file should be create after snapshot
|
|
-L : Include robocopy log into logfile
|
|
-i : Incremental
|
|
-d : Debug. Display the robocopy command without running it. Useful
|
|
when you encountered the error and willing debug it.
|
|
-N : use NET access to release server(s) to determine the snap location.
|
|
Default behavior is rely on DFS.
|
|
-B : specify the release server to form the snap location. Only used when -N
|
|
flag set
|
|
|
|
|
|
-? Displays usage
|
|
|
|
Example:
|
|
1. Snapshot US 2121
|
|
$0 -n 2121
|
|
2. Snapshot US 2222 with userlst.txt incrementally
|
|
$0 -n 2222 -f userlst.txt -i
|
|
3. Snapshot US 2233 from d:\\nt8.binaries.x86fre to f:\\nt9.binaries.x86fre
|
|
with userlst.txt and store buildnumber and time stamp to mynote.txt.
|
|
$0 -n 2233 -s d:\\nt8.binaries.x86fre -t f:\\nt9.binaries.x86fre -f userlst.txt -B mynote.txt
|
|
4. Dummy snap the idx02 build in the Razzle enlisted in main branch.
|
|
$0 -n 3505 -b idx02 -d
|
|
USAGE
|
|
exit 0;
|
|
}
|
|
|
|
|
|
&parseargs('?' => \&Usage,
|
|
'n:' => \$BuildNum,
|
|
's:' => \$SourceTree,
|
|
't:' => \$TargetTree,
|
|
'y:' => \$_BuildBranch,
|
|
'f:' => \$SnapList,
|
|
'L' => \$ROBOCOPYLOG,
|
|
'i' => \$Incremental,
|
|
'd' => \$DEBUG,
|
|
'N' => \$NETVIEW,
|
|
'B:' => \$BinarySnapServer
|
|
);
|
|
|
|
# Validate the option given as parameter.
|
|
&ValidateParams;
|
|
|
|
# Step 4: Call the CmdMain function
|
|
&CmdMain();
|
|
|
|
|
|
# -------------------------------------------------------------------------------------------
|
|
# Script: snapbin.pl
|
|
# Purpose: Snapshot US binaries tree to INTL.
|
|
# SD Location: %sdxroot%\tools\postbuildscripts
|
|
#
|
|
# (1) Code section description:
|
|
# CmdMain - Prepare the robocopyCmd, execute and parse its log
|
|
# PrepareRoboCopyCmd - Prepare the Robocopy command
|
|
# ExecuteRoboCopy - Execute the Robocopy command and test the return value
|
|
# ParseLogFile - Parse the logfile, append logfile from temp logfile
|
|
#
|
|
# (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.
|
|
#
|
|
# (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<SnapBin> - Snapshot US Binaries tree to INTL
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
&SnapBin::PrepareRoboCopyCmd;
|
|
&SnapBin::ExecuteRoboCopy;
|
|
&SnapBin::ParseLogFile;
|
|
&SnapBin::CreateBldInfo;
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
According SnapList,
|
|
PrepareRoboCopyCmd will prepare the command, such as:
|
|
Robocopy /MIR /S /E $SourceTree $TargetTree /XD xxxx /XF xxxx /LOG+:$ENV{logfile}.temp
|
|
ExecuteRoboCopy execute the command and verify its log.
|
|
And, ParseLogFile will append temp logfile to $ENV{logfile} and generate a separate list into log.
|
|
Final, create BldInfo file in nt root.
|
|
|
|
=head1 INSTANCES
|
|
|
|
=head2 $SourceTree
|
|
US Tree, default is \\\\ntdev\\release\\<_BuildBranch>\\usa\\<BuildNum>\\<_BuildArch><_BuildType>\\bin
|
|
=head2 $TargetTree
|
|
INTL Tree, default is _NTTREE
|
|
=head2 $SnapList
|
|
Snap List FileName, default is SnapList.txt
|
|
=head2 $BuildNum
|
|
Build Number, necessary defined. No default value
|
|
=head2 %SnapList
|
|
The hash stored by HashText::Read_Text_Hash from file $SnapList.
|
|
=head2 $RoboCopyCmd
|
|
The command for ExecuteRoboCopy execute
|
|
=head1 METHODS
|
|
|
|
=head2 PrepareRoboCopyCmd
|
|
$SnapBin::SourceTree = "f:\\foo";
|
|
$SnapBin::TargetTree = "f:\\bar";
|
|
$SnapBin::SnapList = "mylist.txt"; # equal to '-' if no exclude list file
|
|
&SnapBin::PrepareRoboCopyCmd;
|
|
system("$SnapBin::RoboCopyCmd");
|
|
|
|
=head2 ExecuteRoboCopy
|
|
$SnapBin::SourceTree = "f:\\foo";
|
|
$SnapBin::TargetTree = "f:\\bar";
|
|
$SnapBin::RoboCopyCmd = "Robocopy /S $SnapBin::SourceTree $SnapBin::TargetTree";
|
|
&SnapBin::ExecuteRoboCopy;
|
|
|
|
=head2 ParseLogFile
|
|
system("robocopy f:\\temp F:\\tempbak /LOG:abc.log");
|
|
&SnapBin::ParseLogFile("abc.log");
|
|
|
|
=head1 SEE ALSO
|
|
|
|
HashText.pm
|
|
|
|
=head1 AUTHOR
|
|
Benson Tan <[email protected]>
|
|
Serguei Kouzmine <[email protected]>
|
|
=cut
|
|
1;
|