778 lines
22 KiB
Batchfile
778 lines
22 KiB
Batchfile
|
@echo off
|
||
|
|
REM ------------------------------------------------------------------
|
||
|
|
REM <<intlsdop.cmd>>
|
||
|
|
REM Perform sd operations for international builds.
|
||
|
|
REM Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
REM Version: < 1.0 > 02/02/2001 Suemiao Rossignol
|
||
|
|
REM ------------------------------------------------------------------
|
||
|
|
perl -x "%~f0" %*
|
||
|
|
goto :EOF
|
||
|
|
#!perl
|
||
|
|
use strict;
|
||
|
|
use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
|
||
|
|
use lib $ENV{RAZZLETOOLPATH};
|
||
|
|
use Logmsg;
|
||
|
|
use ParseArgs;
|
||
|
|
use File::Basename;
|
||
|
|
use BuildName;
|
||
|
|
use GetIniSetting;
|
||
|
|
use comlib;
|
||
|
|
use cklang;
|
||
|
|
use cktarg;
|
||
|
|
use filestat;
|
||
|
|
use vars (qw($LOCPART $MAIN));
|
||
|
|
|
||
|
|
my $LOCDIRS = {"locpart"=>"lp",
|
||
|
|
"dnsrv_dev"=>"dnsrvdev"};
|
||
|
|
|
||
|
|
my $scriptname = basename( $0 );
|
||
|
|
|
||
|
|
|
||
|
|
sub Usage {
|
||
|
|
my $SELF = $0;
|
||
|
|
$SELF =~ s/.*\\//g;
|
||
|
|
print<<USAGE;
|
||
|
|
Perform Integrate, reverse integrate or sync for internatioanl builds steps.
|
||
|
|
|
||
|
|
|
||
|
|
Usage:
|
||
|
|
$SELF [-l:<lang> | -d:<location>] -o:<op> [-t:<timestamp>][-pf] [-y:<branch>] [-c]
|
||
|
|
|
||
|
|
-l Language. Default is "usa".
|
||
|
|
|
||
|
|
The operation $SELF performs is language dependent.
|
||
|
|
Not all op/lang combinations are allowed.
|
||
|
|
|
||
|
|
If "usa", sync the source projects under SDXROOT.
|
||
|
|
If <lang>, RI or sync the localization projects for the given <lang>.
|
||
|
|
|
||
|
|
-d: Location.
|
||
|
|
This could be %sdxroot% or %RazzleToolPath%
|
||
|
|
Perform sd <operation> on <location>.
|
||
|
|
|
||
|
|
-o: SD operation.
|
||
|
|
if "r", perform loc RI.
|
||
|
|
if "s", perform sync.
|
||
|
|
if "v", perform verification.
|
||
|
|
if "u", perform updates. This option is not yet functional.
|
||
|
|
|
||
|
|
-t Timestamp. Used for Integrate/RI/syncing the SD files.
|
||
|
|
Default is the latest time.
|
||
|
|
|
||
|
|
-f: Force operation
|
||
|
|
|
||
|
|
-i: Interactive mode (prompts for user input)
|
||
|
|
|
||
|
|
-p Powerless.
|
||
|
|
Do not perform sd operation.
|
||
|
|
|
||
|
|
-y <branch> the branch parameter which defaults to "locpart".
|
||
|
|
|
||
|
|
-c Force sync to current, It only works when used with -d:%RazzleToolPath%
|
||
|
|
|
||
|
|
/? Displays usage.
|
||
|
|
|
||
|
|
Examples:
|
||
|
|
|
||
|
|
$SELF -d:%sdxroot% -t:2000/10/01:18:00 -o:s
|
||
|
|
Sync the source tree at the given timestamp.
|
||
|
|
|
||
|
|
$SELF -l:ger -t:2000/09/09:12:34 -o:r
|
||
|
|
Reverse integrate German localization projects at the given timestamp.
|
||
|
|
|
||
|
|
$SELF -l:JPN -t:2000/09/09:12:34 -o:r -y:dnsrv_dev
|
||
|
|
Reverse integrate Japanese localization projects from dnsrv_dev
|
||
|
|
to dnsrv at the given timestamp.
|
||
|
|
|
||
|
|
$SELF -l:ger -o:s
|
||
|
|
Sync the German localization projects at the latest time.
|
||
|
|
|
||
|
|
$SELF -l:ger -o:u
|
||
|
|
Open, edit and submit files from German localization projects to the
|
||
|
|
destination needed by the build. This option is not yet functional.
|
||
|
|
|
||
|
|
USAGE
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
my( $lang, $destDir, $syncTime, $operation, $powerLess, $force, $intact);
|
||
|
|
my( $isFake, $sdxroot, $toolDir, $pbsDir, $isCurrent );
|
||
|
|
|
||
|
|
if( !&GetParams ) { exit(1);}
|
||
|
|
exit(&main);
|
||
|
|
|
||
|
|
#-----------------------------------------------------------------------------
|
||
|
|
# GetParams - parse & validate command line
|
||
|
|
#-----------------------------------------------------------------------------
|
||
|
|
sub GetParams
|
||
|
|
{
|
||
|
|
parseargs('?' => \&Usage, 'l:' =>\$ENV{lang}, 'd:' => \$destDir,'t:' =>\$syncTime, 'o:' =>\$operation
|
||
|
|
,"y:" => \$LOCPART,
|
||
|
|
'p' =>\$powerLess, 'f' => \$force, 'i' => \$intact, 'c' => \$isCurrent );
|
||
|
|
$LOCPART = "locpart" unless $LOCPART;
|
||
|
|
$MAIN = "main" unless $MAIN ;
|
||
|
|
|
||
|
|
|
||
|
|
$ENV{lang} = "USA" if( !$ENV{lang} );
|
||
|
|
$lang = $ENV{lang};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#####The lang not usa, but template default it got to be, so verify with destDir
|
||
|
|
if ($operation eq "u"){
|
||
|
|
errmsg("This option is not yet functional.");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1 if( lc($lang) eq "usa" && !$destDir );
|
||
|
|
|
||
|
|
if( lc($lang) eq "usa" && $destDir )
|
||
|
|
{
|
||
|
|
if( $destDir eq $ENV{sdxroot} )
|
||
|
|
{
|
||
|
|
if( $operation ne "s" )
|
||
|
|
{
|
||
|
|
errmsg("Invalid operation $operation for $destDir" );
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
elsif( $destDir eq $ENV{RazzleToolPath} )
|
||
|
|
{
|
||
|
|
if( !( $operation eq "r" || $operation eq "s" ) )
|
||
|
|
{
|
||
|
|
errmsg("Invalid operation $operation for $destDir" );
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
errmsg( "Invalid location $destDir" );
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( !( $operation eq "r" || $operation eq "s" || $operation eq "v") )
|
||
|
|
{
|
||
|
|
errmsg("Invalid operation $operation for $lang" );
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
#-----------------------------------------------------------------------------
|
||
|
|
sub main
|
||
|
|
{
|
||
|
|
#####Set LogFile & ErrFile
|
||
|
|
my $curTime = &CurTime();
|
||
|
|
|
||
|
|
$ENV{temp} = "$ENV{temp}\\$lang";
|
||
|
|
system( "md $ENV{temp}" ) if( !(-e $ENV{temp} ) );
|
||
|
|
$ENV{LOGFILE} = "$ENV{temp}\\$scriptname.log.$curTime";
|
||
|
|
$ENV{ERRFILE} = "$ENV{temp}\\$scriptname.err.$curTime";
|
||
|
|
timemsg( "Start [$scriptname]" );
|
||
|
|
if( $syncTime && ( $syncTime !~ /^([@#].+)$/ )){ $syncTime = "\@".$syncTime; }
|
||
|
|
if( $powerLess ) { $isFake = "-n"; } else { $isFake="";}
|
||
|
|
if( $force ) { $force = "-f"; } else { $force="";}
|
||
|
|
|
||
|
|
$sdxroot = $ENV{SDXROOT};
|
||
|
|
$toolDir = $ENV{RazzleToolPath};
|
||
|
|
$pbsDir = "$toolDir\\PostBuildScripts";
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
if( uc($lang) eq "USA" && !$destDir ) #sync source tree#
|
||
|
|
{
|
||
|
|
&comlib::ExecuteSystem( "cd /d $ENV{SDXROOT} & sdx sync $force $isFake ...$syncTime -q -h" ); #added $force switch
|
||
|
|
#if timestamp specified, sync tools & pbs to latest
|
||
|
|
if($syncTime){ &SyncTools;}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( $destDir )
|
||
|
|
{
|
||
|
|
|
||
|
|
if( $destDir eq $sdxroot )
|
||
|
|
{
|
||
|
|
&SyncSourceTree;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
&IorRIorSyncTools;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
elsif( $lang )
|
||
|
|
{
|
||
|
|
if(!&CheckOpened("$sdxroot\\loc\\res\\TOOLS",
|
||
|
|
"$sdxroot\\loc\\res\\$lang",
|
||
|
|
"$sdxroot\\loc\\bin\\$lang") ||
|
||
|
|
!&VryFieZs("writable", "$sdxroot\\loc\\res\\$lang",
|
||
|
|
"$sdxroot\\loc\\res\\TOOLS")
|
||
|
|
)
|
||
|
|
|
||
|
|
# do not check write bit for loc bin drop path files
|
||
|
|
{
|
||
|
|
return 0 if( !$intact );
|
||
|
|
}
|
||
|
|
if( $intact && &PromptAction("sd client") == 1 ) #only do sd client in interactive mode
|
||
|
|
{ #we'll assume its right in automated case#
|
||
|
|
&comlib::ExecuteSystem( "cd $sdxroot\\loc\\res\\TOOLS& sd client -o");
|
||
|
|
&comlib::ExecuteSystem( "cd $sdxroot\\loc\\res\\$lang& sd client -o");
|
||
|
|
&comlib::ExecuteSystem( "cd $sdxroot\\loc\\bin\\$lang& sd client -o");
|
||
|
|
}
|
||
|
|
|
||
|
|
if( $operation eq "v" )
|
||
|
|
{
|
||
|
|
&CompMainLocpart;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
&RIorSyncLocTree;
|
||
|
|
if( $operation eq "r")
|
||
|
|
{
|
||
|
|
return 0 unless &VryFieZs("zerosize",
|
||
|
|
"$sdxroot\\loc\\res\\$lang",
|
||
|
|
"$sdxroot\\loc\\bin\\$lang");
|
||
|
|
&CompMainLocpart;
|
||
|
|
}
|
||
|
|
|
||
|
|
if( $operation eq "s")
|
||
|
|
{
|
||
|
|
&addsyncInt();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# VryFieZs - verify files in directories
|
||
|
|
# usage VryFieZs(test, dirname,dirname,...)
|
||
|
|
# currently as "test" the "writeable" or "zerosize" may be used.
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub VryFieZs(){
|
||
|
|
my $test = shift;
|
||
|
|
my $GOOD = 1;
|
||
|
|
foreach my $path (@_)
|
||
|
|
{
|
||
|
|
chdir $path;
|
||
|
|
my @res = (qx(cd $path &dir /s/b/a-d .) =~ /.+\n/mig);
|
||
|
|
map {chomp} @res;
|
||
|
|
my @bad = &filestat($test, @res);
|
||
|
|
next unless scalar(@bad);
|
||
|
|
@bad = map {qx(sd.exe have $_ 2>NUL)} @bad;
|
||
|
|
map {errmsg $_} @bad ;
|
||
|
|
$GOOD=0 if scalar(@bad);
|
||
|
|
}
|
||
|
|
$GOOD;
|
||
|
|
}
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# SyncTools() - Syncs tools & PBS to latest - all others to timestamp
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub SyncTools()
|
||
|
|
{
|
||
|
|
my ($d, @dirs);
|
||
|
|
my $sTs = "";
|
||
|
|
if(!$isCurrent)
|
||
|
|
{
|
||
|
|
$sTs = $syncTime;
|
||
|
|
}
|
||
|
|
|
||
|
|
@dirs = `cd $sdxroot\\tools &dir /ad /b`;
|
||
|
|
for $d (@dirs)
|
||
|
|
{
|
||
|
|
if( $d !~ /postbuildscripts/i)
|
||
|
|
{
|
||
|
|
chomp $d;
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\$d &sd sync $force $isFake ...$syncTime");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\$d &sd diff -f -sadeE ...$syncTime");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools &sd sync $force $isFake *$sTs");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools &sd diff -f -sadeE *$sTs");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\postbuildscripts &sd sync $force $isFake ...$sTs");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\postbuildscripts &sd diff -f -sadeE ...$sTs");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\ploc &sd sync $force $isFake ...");
|
||
|
|
&comlib::ExecuteSystem("cd $sdxroot\\tools\\ploc &sd diff -f -sadeE ...");
|
||
|
|
return 0 if (!CheckOpened("$sdxroot\\tools"));
|
||
|
|
# || !&VryFieZs("writable","$sdxroot\\tools") ;
|
||
|
|
# //depot/dnsrv/root/tools/x86/managed/urt/v1.1.4322/config/... is often read-write.
|
||
|
|
# Ignore that for now.
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# SDSubmit($) - Automates Submittals w/ arg:comment
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub SDSubmit($$)
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
my(@chglist, $fout, $l);
|
||
|
|
my($comment, $dir) = @_;
|
||
|
|
@chglist = `cd $dir &sd change -o`;
|
||
|
|
|
||
|
|
my $res = 0;
|
||
|
|
$l = 0;
|
||
|
|
while( $l < @chglist && $chglist[$l++] !~ /^Files:/ ){}
|
||
|
|
while( $l < @chglist && $chglist[$l++] =~ /\/\/depot.*/ ){
|
||
|
|
$res = 1;
|
||
|
|
last;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($res == 0){
|
||
|
|
logmsg("No files to submit.\n");
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
open fout, ">$ENV{TMP}\\_sdchglst.$lang.tmp" || return 0;
|
||
|
|
for $l (@chglist) {
|
||
|
|
$l =~ s/\<enter description here\>/$comment/;
|
||
|
|
print fout $l;
|
||
|
|
|
||
|
|
}
|
||
|
|
close fout;
|
||
|
|
print `cd $dir &type $ENV{TMP}\\_sdchglst.$lang.tmp | sd submit -i`;
|
||
|
|
`del /f $ENV{TMP}\\_sdchglst.$lang.tmp`;
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# CheckOpened(@) - validate no opened files in $arg:tree
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
sub CheckOpened(@)
|
||
|
|
{
|
||
|
|
my @path = @_;
|
||
|
|
my $res;
|
||
|
|
foreach my $path (@path){
|
||
|
|
logmsg("cd $path &sd opened ...");
|
||
|
|
$res = `cd $path &sd opened ...`;
|
||
|
|
if($res ne ''){
|
||
|
|
print $res;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# RIorSyncLocTree - RI's or syncs loc tree
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub RIorSyncLocTree
|
||
|
|
{
|
||
|
|
my( $cmdLine, $action, $res, $bldno );
|
||
|
|
|
||
|
|
my %myCmds = ( "1"=>"sd sync $force $isFake ...", #added $force switch
|
||
|
|
"2"=>"sd integrate -b $LOCPART -d -r -i $force $isFake ...$syncTime",
|
||
|
|
"3"=>"sd resolve $isFake -ab ...",
|
||
|
|
"4"=>"sd resolve $isFake -at ...",
|
||
|
|
"5"=>"sd resolve -n ...",
|
||
|
|
"6"=>"sd submit ...",
|
||
|
|
"7"=>"sd diff -f -sadeE ...$syncTime" );
|
||
|
|
|
||
|
|
if( $operation eq "s" ) { $myCmds{"1"} = "sd sync $force $isFake ...$syncTime";}
|
||
|
|
|
||
|
|
my %myDirs = ( "1"=>"$sdxroot\\loc\\res\\$lang",
|
||
|
|
"2"=>"$sdxroot\\loc\\bin\\$lang");
|
||
|
|
|
||
|
|
if( $operation =~ /[rs]/i) { $myDirs{"3"} = "$sdxroot\\loc\\res\\TOOLS";}
|
||
|
|
|
||
|
|
for my $dirKey ( sort keys %myDirs )
|
||
|
|
{
|
||
|
|
for my $theKey ( sort { $a <=> $b } keys %myCmds )
|
||
|
|
{
|
||
|
|
last if( $theKey eq "5" && !$intact );
|
||
|
|
$action = 1;
|
||
|
|
$cmdLine="cd $myDirs{$dirKey}& $myCmds{$theKey}";
|
||
|
|
if($intact){ $action = &PromptAction( $cmdLine );}
|
||
|
|
$res = &comlib::ExecuteSystem( $cmdLine ) if( $action == 1);
|
||
|
|
if(!$intact && $res == 0 )
|
||
|
|
{
|
||
|
|
errmsg("Errors encountered... exiting\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
#####Stop here, if sync or automation
|
||
|
|
if( $operation eq "s" )
|
||
|
|
{
|
||
|
|
&comlib::ExecuteSystem("cd $myDirs{$dirKey}& $myCmds{7}" );
|
||
|
|
last;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
#perform submit here - since 2nd case isnt a system call, can't add to myCmds hash
|
||
|
|
if($operation eq "r" && !$isFake && !$intact)
|
||
|
|
{
|
||
|
|
$MAIN = undef;
|
||
|
|
&getMainBranchName();
|
||
|
|
if(!SDSubmit("RI: [ntdev\\ntbuild] $lang $LOCPART->$MAIN", $myDirs{$dirKey}))
|
||
|
|
{
|
||
|
|
errmsg("Errors encountered submitting changes... exiting\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# CompmainLocpart - compares RI & LP branches
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub CompMainLocpart
|
||
|
|
{
|
||
|
|
my( $cmdLine, $action, $res );
|
||
|
|
|
||
|
|
my %myCmds = ( "1"=>"sd sync $force $isFake ...$syncTime",
|
||
|
|
"2"=>"sd sync $force $isFake ...$syncTime");
|
||
|
|
my $LocDir = $LOCDIRS -> {lc($LOCPART)};
|
||
|
|
my %myDirs = ( "1"=>"\\$LocDir\\loc\\res\\$lang",
|
||
|
|
"2"=>"\\$LocDir\\loc\\bin\\$lang");
|
||
|
|
|
||
|
|
|
||
|
|
for my $theKey ( sort keys %myCmds )
|
||
|
|
{
|
||
|
|
$cmdLine="cd $myDirs{$theKey}& $myCmds{$theKey}";
|
||
|
|
if($intact)
|
||
|
|
{
|
||
|
|
$action = &PromptAction( $cmdLine );
|
||
|
|
next if( $action == 2 );
|
||
|
|
}
|
||
|
|
$res = &comlib::ExecuteSystem( $cmdLine );
|
||
|
|
if(!$intact && $res == 0 )
|
||
|
|
{
|
||
|
|
errmsg("Differences found during: $cmdLine\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#do comparison
|
||
|
|
if($intact) #if interactive use windiff / else compdir
|
||
|
|
{
|
||
|
|
for $cmdLine ("start windiff $sdxroot\\loc\\res\\$lang \\$LocDir\\loc\\res\\$lang",
|
||
|
|
"start windiff $sdxroot\\loc\\bin\\$lang \\$LocDir\\loc\\bin\\$lang")
|
||
|
|
{
|
||
|
|
$action = &PromptAction( $cmdLine );
|
||
|
|
&comlib::ExecuteSystem( $cmdLine );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for $cmdLine (" compdir $sdxroot\\loc\\res\\$lang \\$LocDir\\loc\\res\\$lang",
|
||
|
|
" compdir $sdxroot\\loc\\bin\\$lang \\$LocDir\\loc\\bin\\$lang")
|
||
|
|
{
|
||
|
|
logmsg("$cmdLine");
|
||
|
|
my @res = `$cmdLine`;
|
||
|
|
if( $? )
|
||
|
|
{
|
||
|
|
errmsg( "Errors found during comparison:\n@res" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------//
|
||
|
|
sub IorRIorSyncTools
|
||
|
|
{
|
||
|
|
my( $cmdLine, $action, $IorRI, $res );
|
||
|
|
|
||
|
|
$IorRI = "";
|
||
|
|
$IorRI = "-r -i" if( $operation eq "r" );
|
||
|
|
|
||
|
|
if($operation eq "s")
|
||
|
|
{
|
||
|
|
&SyncTools();
|
||
|
|
}
|
||
|
|
# else
|
||
|
|
# {
|
||
|
|
# my %myCmds = ( "1" => "sd opened ...",
|
||
|
|
# "2"=>"sd sync $force $isFake *",
|
||
|
|
# "3"=>"sd sync $force $isFake ...",
|
||
|
|
# "4"=>"sd integrate -b intlred $IorRI $force $isFake *$syncTime",
|
||
|
|
# "5"=>"sd integrate -b intlred $IorRI $force $isFake ...$syncTime",
|
||
|
|
# "6"=>"sd resolve $isFake -ab ...",
|
||
|
|
# "7"=>"sd resolve $isFake -am ...",
|
||
|
|
# "8"=>"sd resolve ...",
|
||
|
|
# "9"=>"sd resolve -n ...",
|
||
|
|
# "10"=>"sd submit ..." );
|
||
|
|
# my %myDirs = ( "1"=>"$toolDir", "2"=>"$toolDir","3"=>"$pbsDir", "4"=>"$toolDir", "5"=>"$pbsDir",
|
||
|
|
# "6"=>"$toolDir","7"=>"$toolDir", "8"=>"$toolDir", "9"=>"$toolDir", "10" =>"$toolDir" );
|
||
|
|
#
|
||
|
|
# for my $theKey ( sort { $a <=> $b } keys %myCmds )
|
||
|
|
# {
|
||
|
|
# $action = 1;
|
||
|
|
# $cmdLine="cd $myDirs{$theKey}& $myCmds{$theKey}";
|
||
|
|
# if($intact){$action = &PromptAction( $cmdLine ); }
|
||
|
|
#
|
||
|
|
# $res = &comlib::ExecuteSystem( $cmdLine )if( $action == 1 );
|
||
|
|
# if(!$intact && $res == 0 )
|
||
|
|
# {
|
||
|
|
# errmsg("**** Errors encountered executing $cmdLine... exiting ****\n");
|
||
|
|
# return 0;
|
||
|
|
# }
|
||
|
|
# }
|
||
|
|
# }
|
||
|
|
}
|
||
|
|
|
||
|
|
sub addsyncInt
|
||
|
|
{
|
||
|
|
# This code is pasted from copylang.pl
|
||
|
|
# The eventual goal is migration and separation.
|
||
|
|
|
||
|
|
my @theHashKey;
|
||
|
|
my $line;
|
||
|
|
my $curKey;
|
||
|
|
my $LCID;
|
||
|
|
my $priLangID;
|
||
|
|
my %tmp;
|
||
|
|
my $theFromFile;
|
||
|
|
my $theToFile;
|
||
|
|
my $theFromRoot;
|
||
|
|
my $theToRoot;
|
||
|
|
my $theFromTree;
|
||
|
|
my $theToTree;
|
||
|
|
my $from;
|
||
|
|
my $to;
|
||
|
|
my $res;
|
||
|
|
my %hashCodes=();
|
||
|
|
|
||
|
|
my $pLocRoot = "$ENV{_NTBINDIR}\\loc\\res\\$lang\\windows\\sources";
|
||
|
|
my $pSrcRoot = $ENV{"SDXROOT"};
|
||
|
|
|
||
|
|
my $theFromTree = "LocTree";
|
||
|
|
my $theFromRoot = $pLocRoot;
|
||
|
|
my $theFromFile = "LocTreeFilename";
|
||
|
|
my $theToTree = "SourceTree";
|
||
|
|
my $theToRoot = $pSrcRoot;
|
||
|
|
my $theToFile = "SourceFilename";
|
||
|
|
|
||
|
|
|
||
|
|
&HashText::Read_Text_Hash( 0, $ENV{RazzleToolPath}."\\Codes.txt", \%hashCodes );
|
||
|
|
# Delete everything that's not international
|
||
|
|
|
||
|
|
delete $hashCodes{RO};
|
||
|
|
delete $hashCodes{CA};
|
||
|
|
delete $hashCodes{CHP};
|
||
|
|
delete $hashCodes{PSU};
|
||
|
|
delete $hashCodes{MIR};
|
||
|
|
delete $hashCodes{TST};
|
||
|
|
|
||
|
|
###---Get Hash value from intlsrc.txt file.----------//
|
||
|
|
my @srcHash=();
|
||
|
|
&HashText::Read_Text_Hash( 1, "$ENV{\"RazzleToolPath\"}\\intlsrc.txt", \@srcHash );
|
||
|
|
|
||
|
|
@theHashKey = ("Target", "SourceFilename", "SourceTree", "LocTree","LocTreeFilename","Comments");
|
||
|
|
|
||
|
|
|
||
|
|
%tmp=();
|
||
|
|
|
||
|
|
for $line( @srcHash)
|
||
|
|
{
|
||
|
|
for $curKey ( @theHashKey )
|
||
|
|
{
|
||
|
|
if( $line->{ $curKey } =~ /^(.*)(\$\(LANG\))(.*)$/ )
|
||
|
|
{
|
||
|
|
$line->{ $curKey } = $1 . lc($lang) .$3;
|
||
|
|
}
|
||
|
|
if( $line->{ $curKey } =~ /^(.*)([c|h])(\$\(PRIMARY_LANG_ID\))(.*)$/ )
|
||
|
|
{
|
||
|
|
if( $lang eq "CHT" || $lang eq "CHS" )
|
||
|
|
{
|
||
|
|
$LCID = substr( $hashCodes{uc($lang)}->{LCID}, 2, length($hashCodes{uc($lang)}->{LCID})-2);
|
||
|
|
$line->{ $curKey } = "prf" . $2 . $LCID .$4;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
$priLangID = "0". substr( $hashCodes{uc($lang)}->{PriLangID}, 2, length($hashCodes{uc($lang)}->{PriLangID})-2);
|
||
|
|
$line->{ $curKey } = $1 . $2. $priLangID .$4;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
$to = $theToRoot."\\". $line->{ $theToTree };
|
||
|
|
if( !exists $tmp{$to} ){ $tmp{$to}=(); }
|
||
|
|
my $todir = "$theToRoot\\$line->{ $theToTree }";
|
||
|
|
my $cmdLine = "md $todir 2\>NUL&pushd $todir&sd sync $force $to";
|
||
|
|
$intact and
|
||
|
|
$res = &PromptAction( $cmdLine );
|
||
|
|
&comlib::ExecuteSystem( $cmdLine );
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
###---Perform Copy now.------------------------------//
|
||
|
|
&dbgmsg("Read targets from intlsrc.txt: \n");
|
||
|
|
|
||
|
|
for $line ( @srcHash )
|
||
|
|
{
|
||
|
|
&dbgmsg($line->{ $theFromTree },"\n");
|
||
|
|
|
||
|
|
if( $lang ne "USA" )
|
||
|
|
{
|
||
|
|
next if( !&cktarg::CkTarg( $line->{'Target'}, uc($lang) ) );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if( $lang ne "USA" )
|
||
|
|
{
|
||
|
|
if( $line->{ $theFromFile } eq ".")
|
||
|
|
{
|
||
|
|
$from = $theFromRoot ."\\". $line->{ $theFromTree }."\\".$line->{ $theToFile };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
$to = $theToRoot."\\". $line->{ $theToTree }. "\\".$line->{ $theToFile };
|
||
|
|
my $todir = "$theToRoot\\$line->{ $theToTree }";
|
||
|
|
my $cmdLine = "md $todir 2\>NUL&pushd $todir&sd sync $force $to";
|
||
|
|
$intact and
|
||
|
|
$res = &PromptAction( $cmdLine );
|
||
|
|
&comlib::ExecuteSystem( $cmdLine );
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
# SyncSourceTree - syncs sdx projects
|
||
|
|
#----------------------------------------------------------------------------
|
||
|
|
sub SyncSourceTree
|
||
|
|
{
|
||
|
|
my( @sdMap, @sdProject, $cmdLine, $action, $res, $sdCmd, @opened );
|
||
|
|
|
||
|
|
if( !open( SDMAP, "$sdxroot\\sd.map") )
|
||
|
|
{
|
||
|
|
errmsg( "Fail to read $sdxroot\\s.map, exit.");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
@sdMap = <SDMAP>;
|
||
|
|
close( SDMAP );
|
||
|
|
|
||
|
|
my $validLine = 0;
|
||
|
|
@sdProject=();
|
||
|
|
for my $curLine ( @sdMap )
|
||
|
|
{
|
||
|
|
chomp $curLine;
|
||
|
|
my @tmpLine = split( /\s+/, $curLine );
|
||
|
|
if( $tmpLine[1] !~ "---" )
|
||
|
|
{
|
||
|
|
next if ( !$validLine );
|
||
|
|
last if( $tmpLine[0] =~ "#" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
$validLine = 1;
|
||
|
|
next;
|
||
|
|
}
|
||
|
|
|
||
|
|
next if( !$tmpLine[1] || $tmpLine[1] =~ "(.*)_(.*)" );
|
||
|
|
next if( $tmpLine[1] eq "root" );
|
||
|
|
push ( @sdProject, $tmpLine[3] );
|
||
|
|
}
|
||
|
|
push ( @sdProject,"developer" );
|
||
|
|
push ( @sdProject,"Mergedcomponents" );
|
||
|
|
push ( @sdProject,"public" );
|
||
|
|
push ( @sdProject,"published" );
|
||
|
|
|
||
|
|
$sdCmd = "sd sync $force $isFake ...$syncTime";
|
||
|
|
$cmdLine = "cd $sdxroot\\@sdProject& $sdCmd";
|
||
|
|
if($intact) {return 1 if( &PromptAction( $cmdLine ) !=1 );}
|
||
|
|
|
||
|
|
for my $theDir( @sdProject )
|
||
|
|
{
|
||
|
|
return 0 if !&VryFieZs("writable", "$sdxroot\\$theDir");
|
||
|
|
$res = CheckOpened("$sdxroot\\$theDir" );
|
||
|
|
if(!$intact && $res == 0 ){ push (@opened, $theDir); }
|
||
|
|
$res = &comlib::ExecuteSystem( "cd $sdxroot\\$theDir& sd sync $force $isFake ...$syncTime" );
|
||
|
|
if(!$intact && $res == 0 ){
|
||
|
|
errmsg("**** Errors encountered during sync. Exiting... ****\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
$res = &comlib::ExecuteSystem( "cd $sdxroot\\$theDir& sd diff -f -sadeE ...$syncTime" );
|
||
|
|
if(!$intact && $res == 0 ){
|
||
|
|
errmsg("**** Errors encountered during sd diff. Exiting... ****\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!&SyncTools) #added SynclatestTools here since we'll always want latest tools
|
||
|
|
{
|
||
|
|
push (@opened, "tools");
|
||
|
|
}
|
||
|
|
|
||
|
|
for my $i(@opened) #report opened files
|
||
|
|
{
|
||
|
|
errmsg(" - Files opened in $i ");
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------//
|
||
|
|
sub PromptAction
|
||
|
|
{
|
||
|
|
my ( $pCmdLine ) = @_;
|
||
|
|
|
||
|
|
my ( $choice ) = -1;
|
||
|
|
my ($theDot) = '.' x ( length( $pCmdLine ) + 10);
|
||
|
|
|
||
|
|
print ( "\nAbout to [$pCmdLine]\n$theDot\n") if( $pCmdLine );
|
||
|
|
|
||
|
|
while ( $choice > 3 || $choice < 1 )
|
||
|
|
{
|
||
|
|
print( "\nPlease choose (1) Continue? (2) Skip (3) Quit? ");
|
||
|
|
chop( $choice=<STDIN> );
|
||
|
|
}
|
||
|
|
print "\n\n";
|
||
|
|
exit(0) if( $choice == 3 );
|
||
|
|
return $choice;
|
||
|
|
}
|
||
|
|
#----------------------------------------------------------------------------//
|
||
|
|
sub CurTime
|
||
|
|
{
|
||
|
|
my ($sec,$min,$hour,$day,$mon,$year) = localtime;
|
||
|
|
$year %= 100;
|
||
|
|
$mon++;
|
||
|
|
return sprintf("%02d%02d%02d-%02d%02d%02d",
|
||
|
|
$mon, $day, $year, $hour, $min, $sec);
|
||
|
|
}
|
||
|
|
|
||
|
|
sub getMainBranchName{
|
||
|
|
last if $MAIN;
|
||
|
|
my $HomeBranch = qx("sd have ... | head -1");
|
||
|
|
$HomeBranch =~ s/\/\/depot\/(\w+)\/.*$/$1/g;
|
||
|
|
print STDERR $HomeBranch;
|
||
|
|
$MAIN = $HomeBranch;
|
||
|
|
}
|
||
|
|
|
||
|
|
1;
|
||
|
|
__END__
|
||
|
|
|
||
|
|
=head1 INITIAL DESIGN
|
||
|
|
<Suemiao Rossignol <suemiaor@microsoft.com>
|
||
|
|
|
||
|
|
=head1 CHANGES
|
||
|
|
<Serguei Kouzmine <sergueik@microsoft.com>
|
||
|
|
|
||
|
|
Rearranging the logic to separate sd update - sd sync - no sd.
|
||
|
|
This rearrangement will involve intlbld.pl, copylang.pl, intlsdop.cmd
|
||
|
|
Please read the usage for all these.
|
||
|
|
|
||
|
|
Q: Is there the way to do it safe and incremental?
|
||
|
|
A: Yes. Possibly.
|
||
|
|
|
||
|
|
Step 1.
|
||
|
|
|
||
|
|
add copylang.pl "sync only" functionality to intlsdop.cmd
|
||
|
|
|
||
|
|
Step 2.
|
||
|
|
|
||
|
|
add intlmap.pl "selective enlist" functionality to intlsdop.cmd
|
||
|
|
and copylang/intlbld
|
||
|
|
add intlsdop.cmd "sync" functionality to copylang/intlbld
|
||
|
|
|
||
|
|
Step 3.
|
||
|
|
|
||
|
|
do a cleanup of redundant code. Define logic in mapping files
|
||
|
|
|