825 lines
26 KiB
C++
825 lines
26 KiB
C++
/*=========================================================================
|
|
|
|
Program: CMake - Cross-Platform Makefile Generator
|
|
Module: $RCSfile$
|
|
Language: C++
|
|
Date: $Date$
|
|
Version: $Revision$
|
|
|
|
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notices for more information.
|
|
|
|
=========================================================================*/
|
|
|
|
#include "cmCTestUpdateHandler.h"
|
|
|
|
#include "cmCTest.h"
|
|
#include "cmake.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmLocalGenerator.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmVersion.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmXMLParser.h"
|
|
|
|
//#include <cmsys/RegularExpression.hxx>
|
|
#include <cmsys/Process.h>
|
|
|
|
// used for sleep
|
|
#ifdef _WIN32
|
|
#include "windows.h"
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <float.h>
|
|
|
|
//----------------------------------------------------------------------
|
|
//**********************************************************************
|
|
class cmCTestUpdateHandlerSVNXMLParser : public cmXMLParser
|
|
{
|
|
public:
|
|
struct t_CommitLog
|
|
{
|
|
int m_Revision;
|
|
std::string m_Author;
|
|
std::string m_Date;
|
|
std::string m_Message;
|
|
};
|
|
cmCTestUpdateHandlerSVNXMLParser(cmCTestUpdateHandler* up)
|
|
: cmXMLParser(), m_UpdateHandler(up), m_MinRevision(-1), m_MaxRevision(-1), m_Verbose(false)
|
|
{
|
|
}
|
|
|
|
int Parse(const char* str)
|
|
{
|
|
m_MinRevision = -1;
|
|
m_MaxRevision = -1;
|
|
int res = this->cmXMLParser::Parse(str);
|
|
if ( m_MinRevision == -1 || m_MaxRevision == -1 )
|
|
{
|
|
return 0;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
typedef std::vector<t_CommitLog> t_VectorOfCommits;
|
|
|
|
t_VectorOfCommits* GetCommits() { return &m_Commits; }
|
|
int GetMinRevision() { return m_MinRevision; }
|
|
int GetMaxRevision() { return m_MaxRevision; }
|
|
|
|
void SetVerbose(bool v) { m_Verbose = v; }
|
|
|
|
protected:
|
|
void StartElement(const char* name, const char** atts)
|
|
{
|
|
if ( strcmp(name, "logentry") == 0 )
|
|
{
|
|
m_CommitLog = t_CommitLog();
|
|
const char* rev = this->FindAttribute(atts, "revision");
|
|
if ( rev)
|
|
{
|
|
m_CommitLog.m_Revision = atoi(rev);
|
|
if ( m_MinRevision < 0 || m_MinRevision > m_CommitLog.m_Revision )
|
|
{
|
|
m_MinRevision = m_CommitLog.m_Revision;
|
|
}
|
|
if ( m_MaxRevision < 0 || m_MaxRevision < m_CommitLog.m_Revision )
|
|
{
|
|
m_MaxRevision = m_CommitLog.m_Revision;
|
|
}
|
|
}
|
|
}
|
|
m_CharacterData.erase(m_CharacterData.begin(), m_CharacterData.end());
|
|
}
|
|
void EndElement(const char* name)
|
|
{
|
|
if ( strcmp(name, "logentry") == 0 )
|
|
{
|
|
if ( m_Verbose )
|
|
{
|
|
std::cout << "\tRevision: " << m_CommitLog.m_Revision<< std::endl;
|
|
std::cout << "\tAuthor: " << m_CommitLog.m_Author.c_str() << std::endl;
|
|
std::cout << "\tDate: " << m_CommitLog.m_Date.c_str() << std::endl;
|
|
std::cout << "\tMessage: " << m_CommitLog.m_Message.c_str() << std::endl;
|
|
}
|
|
m_Commits.push_back(m_CommitLog);
|
|
}
|
|
else if ( strcmp(name, "author") == 0 )
|
|
{
|
|
m_CommitLog.m_Author.assign(&(*(m_CharacterData.begin())), m_CharacterData.size());
|
|
}
|
|
else if ( strcmp(name, "date") == 0 )
|
|
{
|
|
m_CommitLog.m_Date.assign(&(*(m_CharacterData.begin())), m_CharacterData.size());
|
|
}
|
|
else if ( strcmp(name, "msg") == 0 )
|
|
{
|
|
m_CommitLog.m_Message.assign(&(*(m_CharacterData.begin())), m_CharacterData.size());
|
|
}
|
|
m_CharacterData.erase(m_CharacterData.begin(), m_CharacterData.end());
|
|
}
|
|
void CharacterDataHandler(const char* data, int length)
|
|
{
|
|
m_CharacterData.insert(m_CharacterData.end(), data, data+length);
|
|
}
|
|
const char* FindAttribute( const char** atts, const char* attribute )
|
|
{
|
|
if ( !atts || !attribute )
|
|
{
|
|
return 0;
|
|
}
|
|
const char **atr = atts;
|
|
while ( *atr && **atr && **(atr+1) )
|
|
{
|
|
if ( strcmp(*atr, attribute) == 0 )
|
|
{
|
|
return *(atr+1);
|
|
}
|
|
atr+=2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
std::vector<char> m_CharacterData;
|
|
cmCTestUpdateHandler* m_UpdateHandler;
|
|
t_CommitLog m_CommitLog;
|
|
|
|
t_VectorOfCommits m_Commits;
|
|
int m_MinRevision;
|
|
int m_MaxRevision;
|
|
bool m_Verbose;
|
|
};
|
|
//**********************************************************************
|
|
//----------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------
|
|
cmCTestUpdateHandler::cmCTestUpdateHandler()
|
|
{
|
|
m_Verbose = false;
|
|
m_CTest = 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
|
|
{
|
|
if ( type && *type )
|
|
{
|
|
std::string stype = cmSystemTools::LowerCase(type);
|
|
if ( stype.find("cvs") != std::string::npos )
|
|
{
|
|
return cmCTestUpdateHandler::e_CVS;
|
|
}
|
|
if ( stype.find("svn") != std::string::npos )
|
|
{
|
|
return cmCTestUpdateHandler::e_SVN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::string stype = cmSystemTools::LowerCase(cmd);
|
|
if ( stype.find("cvs") != std::string::npos )
|
|
{
|
|
return cmCTestUpdateHandler::e_CVS;
|
|
}
|
|
if ( stype.find("svn") != std::string::npos )
|
|
{
|
|
return cmCTestUpdateHandler::e_SVN;
|
|
}
|
|
}
|
|
return cmCTestUpdateHandler::e_CVS;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//clearly it would be nice if this were broken up into a few smaller
|
|
//functions and commented...
|
|
int cmCTestUpdateHandler::ProcessHandler()
|
|
{
|
|
int count = 0;
|
|
int updateType = e_CVS;
|
|
std::string::size_type cc, kk;
|
|
|
|
|
|
// Get source dir
|
|
const char* sourceDirectory = this->GetOption("SourceDirectory");
|
|
if ( !sourceDirectory )
|
|
{
|
|
std::cerr << "Cannot find SourceDirectory key in the DartConfiguration.tcl" << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "Updating the repository: " << sourceDirectory << std::endl;
|
|
|
|
// Get update command
|
|
std::string updateCommand = m_CTest->GetDartConfiguration("UpdateCommand");
|
|
if ( updateCommand.empty() )
|
|
{
|
|
updateCommand = m_CTest->GetDartConfiguration("CVSCommand");
|
|
if ( updateCommand.empty() )
|
|
{
|
|
updateCommand = m_CTest->GetDartConfiguration("SVNCommand");
|
|
if ( updateCommand.empty() )
|
|
{
|
|
std::cerr << "Cannot find CVSCommand, SVNCommand, or UpdateCommand key in the DartConfiguration.tcl" << std::endl;
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
updateType = e_SVN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
updateType = e_CVS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
updateType = this->DetermineType(updateCommand.c_str(), m_CTest->GetDartConfiguration("UpdateType").c_str());
|
|
}
|
|
|
|
// And update options
|
|
std::string updateOptions = m_CTest->GetDartConfiguration("UpdateOptions");
|
|
if ( updateOptions.empty() )
|
|
{
|
|
switch (updateType)
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
updateOptions = m_CTest->GetDartConfiguration("CVSUpdateOptions");
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
updateOptions = m_CTest->GetDartConfiguration("SVNUpdateOptions");
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get update time
|
|
std::string extra_update_opts;
|
|
if ( m_CTest->GetTestModel() == cmCTest::NIGHTLY )
|
|
{
|
|
struct tm* t = cmCTest::GetNightlyTime(m_CTest->GetDartConfiguration("NightlyStartTime"),
|
|
m_Verbose, m_CTest->GetTomorrowTag());
|
|
char current_time[1024];
|
|
sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d",
|
|
t->tm_year + 1900,
|
|
t->tm_mon + 1,
|
|
t->tm_mday,
|
|
t->tm_hour,
|
|
t->tm_min,
|
|
t->tm_sec);
|
|
std::string today_update_date = current_time;
|
|
|
|
// TODO: SVN
|
|
switch ( updateType )
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
extra_update_opts += "-D \"" + today_update_date +" UTC\"";
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
extra_update_opts += "-r \"{" + today_update_date +" +0000}\"";
|
|
break;
|
|
}
|
|
}
|
|
|
|
// First, check what the current state of repository is
|
|
std::string command = "";
|
|
switch( updateType )
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
// TODO: CVS - for now just leave empty
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
command = updateCommand + " info";
|
|
break;
|
|
}
|
|
|
|
cmGeneratedFileStream ofs;
|
|
if ( !m_CTest->GetShowOnly() )
|
|
{
|
|
m_CTest->OpenOutputFile("Temporary", "LastUpdate.log", ofs);
|
|
}
|
|
|
|
// CVS variables
|
|
// SVN variables
|
|
int svn_current_revision = 0;
|
|
int svn_latest_revision = 0;
|
|
int svn_use_status = 0;
|
|
|
|
std::string goutput;
|
|
int retVal = 0;
|
|
bool res = true;
|
|
|
|
if ( !command.empty() )
|
|
{
|
|
if ( m_Verbose )
|
|
{
|
|
std::cout << "* Get repository information: " << command.c_str() << std::endl;
|
|
}
|
|
if ( !m_CTest->GetShowOnly() )
|
|
{
|
|
res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput,
|
|
&retVal, sourceDirectory,
|
|
m_Verbose, 0 /*m_TimeOut*/);
|
|
if ( ofs )
|
|
{
|
|
ofs << "--- Update information ---" << std::endl;
|
|
ofs << goutput << std::endl;
|
|
}
|
|
switch ( updateType )
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
// TODO: CVS - for now just leave empty
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
{
|
|
cmsys::RegularExpression current_revision_regex("Revision: ([0-9]+)");
|
|
if ( current_revision_regex.find(goutput.c_str()) )
|
|
{
|
|
std::string currentRevisionString = current_revision_regex.match(1);
|
|
svn_current_revision = atoi(currentRevisionString.c_str());
|
|
std::cout << " Old revision of repository is: " << svn_current_revision << std::endl;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Update with command: " << command << std::endl;
|
|
}
|
|
}
|
|
|
|
|
|
command = "";
|
|
switch( updateType )
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
command = updateCommand + " -z3 update " + updateOptions +
|
|
" " + extra_update_opts;
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
command = updateCommand + " update " + updateOptions +
|
|
" " + extra_update_opts;
|
|
}
|
|
cmGeneratedFileStream os;
|
|
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os, true) )
|
|
{
|
|
std::cerr << "Cannot open log file" << std::endl;
|
|
}
|
|
std::string start_time = m_CTest->CurrentTime();
|
|
double elapsed_time_start = cmSystemTools::GetTime();
|
|
|
|
if ( m_Verbose )
|
|
{
|
|
std::cout << "* Update repository: " << command.c_str() << std::endl;
|
|
}
|
|
if ( !m_CTest->GetShowOnly() )
|
|
{
|
|
res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput,
|
|
&retVal, sourceDirectory,
|
|
m_Verbose, 0 /*m_TimeOut*/);
|
|
if ( ofs )
|
|
{
|
|
ofs << "--- Update repository ---" << std::endl;
|
|
ofs << goutput << std::endl;;
|
|
}
|
|
}
|
|
|
|
os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
|
|
<< "<Update mode=\"Client\" Generator=\"ctest-"
|
|
<< cmVersion::GetCMakeVersion() << "\">\n"
|
|
<< "\t<Site>" << m_CTest->GetDartConfiguration("Site") << "</Site>\n"
|
|
<< "\t<BuildName>" << m_CTest->GetDartConfiguration("BuildName")
|
|
<< "</BuildName>\n"
|
|
<< "\t<BuildStamp>" << m_CTest->GetCurrentTag() << "-"
|
|
<< m_CTest->GetTestModelString() << "</BuildStamp>" << std::endl;
|
|
os << "\t<StartDateTime>" << start_time << "</StartDateTime>\n"
|
|
<< "\t<UpdateCommand>" << m_CTest->MakeXMLSafe(command)
|
|
<< "</UpdateCommand>\n"
|
|
<< "\t<UpdateReturnStatus>";
|
|
if ( !res || retVal )
|
|
{
|
|
os << "Update error: ";
|
|
os << m_CTest->MakeXMLSafe(goutput);
|
|
std::cerr << "Update with command: " << command << " failed" << std::endl;
|
|
}
|
|
os << "</UpdateReturnStatus>" << std::endl;
|
|
|
|
// Even though it failed, we may have some useful information. Try to continue...
|
|
std::vector<cmStdString> lines;
|
|
cmSystemTools::Split(goutput.c_str(), lines);
|
|
|
|
// CVS style regular expressions
|
|
cmsys::RegularExpression cvs_date_author_regex("^date: +([^;]+); +author: +([^;]+); +state: +[^;]+;");
|
|
cmsys::RegularExpression cvs_revision_regex("^revision +([^ ]*) *$");
|
|
cmsys::RegularExpression cvs_end_of_file_regex("^=============================================================================$");
|
|
cmsys::RegularExpression cvs_end_of_comment_regex("^----------------------------$");
|
|
|
|
// Subversion style regular expressions
|
|
cmsys::RegularExpression svn_status_line_regex("^ *([0-9]+) *([0-9]+) *([^ ]+) *([^ ][^\t\r\n]*)[ \t\r\n]*$");
|
|
cmsys::RegularExpression svn_latest_revision_regex("(Updated to|At) revision ([0-9]+)\\.");
|
|
|
|
cmsys::RegularExpression file_update_line("([A-Z]) *(.*)");
|
|
std::string current_path = "<no-path>";
|
|
bool first_file = true;
|
|
|
|
cmCTestUpdateHandler::AuthorsToUpdatesMap authors_files_map;
|
|
int num_updated = 0;
|
|
int num_modified = 0;
|
|
int num_conflicting = 0;
|
|
// In subversion, get the latest revision
|
|
if ( updateType == cmCTestUpdateHandler::e_SVN )
|
|
{
|
|
for ( cc= 0 ; cc < lines.size(); cc ++ )
|
|
{
|
|
const char* line = lines[cc].c_str();
|
|
if ( svn_latest_revision_regex.find(line) )
|
|
{
|
|
svn_latest_revision = atoi(svn_latest_revision_regex.match(2).c_str());
|
|
}
|
|
}
|
|
}
|
|
if ( updateType == cmCTestUpdateHandler::e_SVN )
|
|
{
|
|
std::cout << " Current revision of repository is: " << svn_latest_revision << std::endl;
|
|
}
|
|
|
|
std::cout << " Gathering version information (each . represents one updated file):" << std::endl;
|
|
int file_count = 0;
|
|
for ( cc= 0 ; cc < lines.size(); cc ++ )
|
|
{
|
|
const char* line = lines[cc].c_str();
|
|
if ( file_update_line.find(line) )
|
|
{
|
|
if ( !m_Verbose )
|
|
{
|
|
if ( file_count == 0 )
|
|
{
|
|
std::cout << " ";
|
|
std::cout.flush();
|
|
}
|
|
std::cout << ".";
|
|
}
|
|
std::cout.flush();
|
|
std::string upChar = file_update_line.match(1);
|
|
std::string upFile = file_update_line.match(2);
|
|
char mod = upChar[0];
|
|
if ( mod != 'M' && mod != 'C' && mod != 'G' )
|
|
{
|
|
count ++;
|
|
}
|
|
const char* file = upFile.c_str();
|
|
//std::cout << "Line" << cc << ": " << mod << " - " << file << std::endl;
|
|
|
|
std::string logcommand;
|
|
switch ( updateType )
|
|
{
|
|
case cmCTestUpdateHandler::e_CVS:
|
|
logcommand = updateCommand + " -z3 log -N \"" + file + "\"";
|
|
break;
|
|
case cmCTestUpdateHandler::e_SVN:
|
|
if ( svn_latest_revision > 0 && svn_latest_revision > svn_current_revision )
|
|
{
|
|
cmOStringStream logCommandStream;
|
|
logCommandStream << updateCommand << " log -r " << svn_current_revision << ":" << svn_latest_revision
|
|
<< " --xml \"" << file << "\"";
|
|
logcommand = logCommandStream.str();
|
|
}
|
|
else
|
|
{
|
|
logcommand = updateCommand + " status --verbose \"" + file + "\"";
|
|
svn_use_status = 1;
|
|
}
|
|
break;
|
|
}
|
|
//std::cout << "Do log: " << logcommand << std::endl;
|
|
std::string output;
|
|
if ( m_Verbose )
|
|
{
|
|
std::cout << "* Get file update information: " << logcommand.c_str() << std::endl;
|
|
}
|
|
res = cmSystemTools::RunSingleCommand(logcommand.c_str(), &output,
|
|
&retVal, sourceDirectory,
|
|
m_Verbose, 0 /*m_TimeOut*/);
|
|
if ( ofs )
|
|
{
|
|
ofs << output << std::endl;
|
|
}
|
|
if ( res && retVal == 0)
|
|
{
|
|
//std::cout << output << std::endl;
|
|
std::string::size_type sline = 0;
|
|
std::string srevision1 = "Unknown";
|
|
std::string sdate1 = "Unknown";
|
|
std::string sauthor1 = "Unknown";
|
|
std::string semail1 = "Unknown";
|
|
std::string comment1 = "";
|
|
std::string srevision2 = "Unknown";
|
|
std::string sdate2 = "Unknown";
|
|
std::string sauthor2 = "Unknown";
|
|
std::string comment2 = "";
|
|
std::string semail2 = "Unknown";
|
|
if ( updateType == cmCTestUpdateHandler::e_CVS )
|
|
{
|
|
bool have_first = false;
|
|
bool have_second = false;
|
|
std::vector<cmStdString> ulines;
|
|
cmSystemTools::Split(output.c_str(), ulines);
|
|
for ( kk = 0; kk < ulines.size(); kk ++ )
|
|
{
|
|
const char* clp = ulines[kk].c_str();
|
|
if ( !have_second && !sline && cvs_revision_regex.find(clp) )
|
|
{
|
|
if ( !have_first )
|
|
{
|
|
srevision1 = cvs_revision_regex.match(1);
|
|
}
|
|
else
|
|
{
|
|
srevision2 = cvs_revision_regex.match(1);
|
|
}
|
|
}
|
|
else if ( !have_second && !sline && cvs_date_author_regex.find(clp) )
|
|
{
|
|
sline = kk + 1;
|
|
if ( !have_first )
|
|
{
|
|
sdate1 = cvs_date_author_regex.match(1);
|
|
sauthor1 = cvs_date_author_regex.match(2);
|
|
}
|
|
else
|
|
{
|
|
sdate2 = cvs_date_author_regex.match(1);
|
|
sauthor2 = cvs_date_author_regex.match(2);
|
|
}
|
|
}
|
|
else if ( sline && cvs_end_of_comment_regex.find(clp) || cvs_end_of_file_regex.find(clp))
|
|
{
|
|
if ( !have_first )
|
|
{
|
|
have_first = true;
|
|
}
|
|
else if ( !have_second )
|
|
{
|
|
have_second = true;
|
|
}
|
|
sline = 0;
|
|
}
|
|
else if ( sline )
|
|
{
|
|
if ( !have_first )
|
|
{
|
|
comment1 += clp;
|
|
comment1 += "\n";
|
|
}
|
|
else
|
|
{
|
|
comment2 += clp;
|
|
comment2 += "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( updateType == cmCTestUpdateHandler::e_SVN )
|
|
{
|
|
if ( svn_use_status )
|
|
{
|
|
cmOStringStream str;
|
|
str << svn_current_revision;
|
|
srevision1 = str.str();
|
|
if (!svn_status_line_regex.find(output))
|
|
{
|
|
std::cerr << "Bad output from SVN status command: " << output << std::endl;
|
|
}
|
|
else if ( svn_status_line_regex.match(4) != file )
|
|
{
|
|
std::cerr << "Bad output from SVN status command. The file name returned: \"" << svn_status_line_regex.match(4) << "\" was different than the file specified: \"" << file << "\"" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
srevision1 = svn_status_line_regex.match(2);
|
|
int latest_revision = atoi(svn_status_line_regex.match(2).c_str());
|
|
if ( svn_current_revision < latest_revision )
|
|
{
|
|
srevision2 = str.str();
|
|
}
|
|
sauthor1 = svn_status_line_regex.match(3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cmCTestUpdateHandlerSVNXMLParser parser(this);
|
|
parser.SetVerbose(m_Verbose);
|
|
if ( parser.Parse(output.c_str()) )
|
|
{
|
|
int minrev = parser.GetMinRevision();
|
|
int maxrev = parser.GetMaxRevision();
|
|
cmCTestUpdateHandlerSVNXMLParser::t_VectorOfCommits::iterator it;
|
|
for ( it = parser.GetCommits()->begin();
|
|
it != parser.GetCommits()->end();
|
|
++ it )
|
|
{
|
|
if ( it->m_Revision == maxrev )
|
|
{
|
|
cmOStringStream mRevStream;
|
|
mRevStream << maxrev;
|
|
srevision1 = mRevStream.str();
|
|
sauthor1 = it->m_Author;
|
|
comment1 = it->m_Message;
|
|
sdate1 = it->m_Date;
|
|
}
|
|
else if ( it->m_Revision == minrev )
|
|
{
|
|
cmOStringStream mRevStream;
|
|
mRevStream << minrev;
|
|
srevision2 = mRevStream.str();
|
|
sauthor2 = it->m_Author;
|
|
comment2 = it->m_Message;
|
|
sdate2 = it->m_Date;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( mod == 'M' )
|
|
{
|
|
comment1 = "Locally modified file\n";
|
|
}
|
|
if ( mod == 'C' )
|
|
{
|
|
comment1 = "Conflict while updating\n";
|
|
}
|
|
std::string path = cmSystemTools::GetFilenamePath(file);
|
|
std::string fname = cmSystemTools::GetFilenameName(file);
|
|
if ( path != current_path )
|
|
{
|
|
if ( !first_file )
|
|
{
|
|
os << "\t</Directory>" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
first_file = false;
|
|
}
|
|
os << "\t<Directory>\n"
|
|
<< "\t\t<Name>" << path << "</Name>" << std::endl;
|
|
}
|
|
if ( mod == 'C' )
|
|
{
|
|
num_conflicting ++;
|
|
os << "\t<Conflicting>" << std::endl;
|
|
}
|
|
else if ( mod == 'G' )
|
|
{
|
|
num_conflicting ++;
|
|
os << "\t<Conflicting>" << std::endl;
|
|
}
|
|
else if ( mod == 'M' )
|
|
{
|
|
num_modified ++;
|
|
os << "\t<Modified>" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
num_updated ++;
|
|
os << "\t<Updated>" << std::endl;
|
|
}
|
|
if ( srevision2 == "Unknown" )
|
|
{
|
|
srevision2 = srevision1;
|
|
}
|
|
if ( m_Verbose )
|
|
{
|
|
std::cout << "File: " << path.c_str() << " / " << fname.c_str() << " was updated by "
|
|
<< sauthor1.c_str() << " to revision: " << srevision1.c_str()
|
|
<< " from revision: " << srevision2.c_str() << std::endl;
|
|
}
|
|
os << "\t\t<File Directory=\"" << cmCTest::MakeXMLSafe(path) << "\">" << cmCTest::MakeXMLSafe(fname)
|
|
<< "</File>\n"
|
|
<< "\t\t<Directory>" << cmCTest::MakeXMLSafe(path) << "</Directory>\n"
|
|
<< "\t\t<FullName>" << cmCTest::MakeXMLSafe(file) << "</FullName>\n"
|
|
<< "\t\t<CheckinDate>" << cmCTest::MakeXMLSafe(sdate1) << "</CheckinDate>\n"
|
|
<< "\t\t<Author>" << cmCTest::MakeXMLSafe(sauthor1) << "</Author>\n"
|
|
<< "\t\t<Email>" << cmCTest::MakeXMLSafe(semail1) << "</Email>\n"
|
|
<< "\t\t<Log>" << cmCTest::MakeXMLSafe(comment1) << "</Log>\n"
|
|
<< "\t\t<Revision>" << srevision1 << "</Revision>\n"
|
|
<< "\t\t<PriorRevision>" << srevision2 << "</PriorRevision>"
|
|
<< std::endl;
|
|
if ( srevision2 != srevision1 )
|
|
{
|
|
os
|
|
<< "\t\t<Revisions>\n"
|
|
<< "\t\t\t<Revision>" << srevision1 << "</Revision>\n"
|
|
<< "\t\t\t<PreviousRevision>" << srevision2 << "</PreviousRevision>\n"
|
|
<< "\t\t\t<Author>" << cmCTest::MakeXMLSafe(sauthor1) << "</Author>\n"
|
|
<< "\t\t\t<Date>" << cmCTest::MakeXMLSafe(sdate1) << "</Date>\n"
|
|
<< "\t\t\t<Comment>" << cmCTest::MakeXMLSafe(comment1) << "</Comment>\n"
|
|
<< "\t\t\t<Email>" << cmCTest::MakeXMLSafe(semail1) << "</Email>\n"
|
|
<< "\t\t</Revisions>\n"
|
|
<< "\t\t<Revisions>\n"
|
|
<< "\t\t\t<Revision>" << srevision2 << "</Revision>\n"
|
|
<< "\t\t\t<PreviousRevision>" << srevision2 << "</PreviousRevision>\n"
|
|
<< "\t\t\t<Author>" << cmCTest::MakeXMLSafe(sauthor2) << "</Author>\n"
|
|
<< "\t\t\t<Date>" << cmCTest::MakeXMLSafe(sdate2) << "</Date>\n"
|
|
<< "\t\t\t<Comment>" << cmCTest::MakeXMLSafe(comment2) << "</Comment>\n"
|
|
<< "\t\t\t<Email>" << cmCTest::MakeXMLSafe(semail2) << "</Email>\n"
|
|
<< "\t\t</Revisions>" << std::endl;
|
|
}
|
|
if ( mod == 'C' )
|
|
{
|
|
os << "\t</Conflicting>" << std::endl;
|
|
}
|
|
else if ( mod == 'G' )
|
|
{
|
|
os << "\t</Conflicting>" << std::endl;
|
|
}
|
|
else if ( mod == 'M' )
|
|
{
|
|
os << "\t</Modified>" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
os << "\t</Updated>" << std::endl;
|
|
}
|
|
cmCTestUpdateHandler::UpdateFiles *u = &authors_files_map[sauthor1];
|
|
cmCTestUpdateHandler::StringPair p;
|
|
p.first = path;
|
|
p.second = fname;
|
|
u->push_back(p);
|
|
|
|
current_path = path;
|
|
}
|
|
file_count ++;
|
|
}
|
|
}
|
|
if ( file_count )
|
|
{
|
|
std::cout << std::endl;
|
|
}
|
|
if ( num_updated )
|
|
{
|
|
std::cout << " Found " << num_updated << " updated files" << std::endl;
|
|
}
|
|
if ( num_modified )
|
|
{
|
|
std::cout << " Found " << num_modified << " locally modified files"
|
|
<< std::endl;
|
|
}
|
|
if ( num_conflicting )
|
|
{
|
|
std::cout << " Found " << num_conflicting << " conflicting files"
|
|
<< std::endl;
|
|
}
|
|
if ( num_modified == 0 && num_conflicting == 0 && num_updated == 0 )
|
|
{
|
|
std::cout << " Project is up-to-date" << std::endl;
|
|
}
|
|
if ( !first_file )
|
|
{
|
|
os << "\t</Directory>" << std::endl;
|
|
}
|
|
|
|
cmCTestUpdateHandler::AuthorsToUpdatesMap::iterator it;
|
|
for ( it = authors_files_map.begin();
|
|
it != authors_files_map.end();
|
|
it ++ )
|
|
{
|
|
os << "\t<Author>\n"
|
|
<< "\t\t<Name>" << it->first << "</Name>" << std::endl;
|
|
cmCTestUpdateHandler::UpdateFiles *u = &(it->second);
|
|
for ( cc = 0; cc < u->size(); cc ++ )
|
|
{
|
|
os << "\t\t<File Directory=\"" << (*u)[cc].first << "\">"
|
|
<< (*u)[cc].second << "</File>" << std::endl;
|
|
}
|
|
os << "\t</Author>" << std::endl;
|
|
}
|
|
|
|
//std::cout << "End" << std::endl;
|
|
std::string end_time = m_CTest->CurrentTime();
|
|
os << "\t<EndDateTime>" << end_time << "</EndDateTime>\n"
|
|
<< "<ElapsedMinutes>" <<
|
|
static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0
|
|
<< "</ElapsedMinutes>"
|
|
<< "</Update>" << std::endl;
|
|
|
|
if ( ofs )
|
|
{
|
|
ofs.close();
|
|
}
|
|
|
|
if (! res || retVal )
|
|
{
|
|
std::cerr << "Error(s) when updating the project" << std::endl;
|
|
std::cerr << "Output: " << goutput << std::endl;
|
|
return -1;
|
|
}
|
|
return count;
|
|
}
|