cmake/Source/CTest/cmCTestP4.cxx

/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2000-2013 Kitware, Inc.

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/
#include "cmCTestP4.h"

#include "cmCTest.h"
#include "cmSystemTools.h"
#include "cmXMLSafe.h"

#include <cmsys/RegularExpression.hxx>
#include <cmsys/ios/sstream>
#include <cmsys/Process.h>

#include <sys/types.h>
#include <time.h>
#include <ctype.h>

//----------------------------------------------------------------------------
cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log):
  cmCTestGlobalVC(ct, log)
{
  this->PriorRev = this->Unknown;
}

//----------------------------------------------------------------------------
cmCTestP4::~cmCTestP4()
{
}

//----------------------------------------------------------------------------
class cmCTestP4::IdentifyParser: public cmCTestVC::LineParser
{
public:
  IdentifyParser(cmCTestP4* p4, const char* prefix,
                 std::string& rev): Rev(rev)
    {
    this->SetLog(&p4->Log, prefix);
    this->RegexIdentify.compile("^Change ([0-9]+) on");
    }
private:
  std::string& Rev;
  cmsys::RegularExpression RegexIdentify;

  bool ProcessLine()
    {
    if(this->RegexIdentify.find(this->Line))
      {
      this->Rev = this->RegexIdentify.match(1);
      return false;
      }
    return true;
    }
};

//----------------------------------------------------------------------------
class cmCTestP4::ChangesParser: public cmCTestVC::LineParser
{
public:
  ChangesParser(cmCTestP4* p4, const char* prefix) : P4(p4)
    {
    this->SetLog(&P4->Log, prefix);
    this->RegexIdentify.compile("^Change ([0-9]+) on");
    }
private:
  cmsys::RegularExpression RegexIdentify;
  cmCTestP4* P4;

  bool ProcessLine()
    {
    if(this->RegexIdentify.find(this->Line))
      {
      P4->ChangeLists.push_back(this->RegexIdentify.match(1));
      }
    return true;
    }
};

//----------------------------------------------------------------------------
class cmCTestP4::UserParser: public cmCTestVC::LineParser
{
public:
  UserParser(cmCTestP4* p4, const char* prefix) : P4(p4)
    {
    this->SetLog(&P4->Log, prefix);
    this->RegexUser.compile("^(.+) <(.*)> \\((.*)\\) accessed (.*)$");
    }
private:
  cmsys::RegularExpression RegexUser;
  cmCTestP4* P4;

  bool ProcessLine()
    {
    if(this->RegexUser.find(this->Line))
      {
      User NewUser;

      NewUser.UserName = this->RegexUser.match(1);
      NewUser.EMail = this->RegexUser.match(2);
      NewUser.Name = this->RegexUser.match(3);
      NewUser.AccessTime = this->RegexUser.match(4);
      P4->Users[this->RegexUser.match(1)] = NewUser;

      return false;
      }
    return true;
    }
};

//----------------------------------------------------------------------------
/* Diff format:
==== //depot/file#rev - /absolute/path/to/file ====
(diff data)
==== //depot/file2#rev - /absolute/path/to/file2 ====
(diff data)
==== //depot/file3#rev - /absolute/path/to/file3 ====
==== //depot/file4#rev - /absolute/path/to/file4 ====
(diff data)
*/
class cmCTestP4::DiffParser: public cmCTestVC::LineParser
{
public:
  DiffParser(cmCTestP4* p4, const char* prefix)
             : P4(p4), AlreadyNotified(false)
    {
    this->SetLog(&P4->Log, prefix);
    this->RegexDiff.compile("^==== (.*)#[0-9]+ - (.*)");
    }
private:
  cmCTestP4* P4;
  bool AlreadyNotified;
  std::string CurrentPath;
  cmsys::RegularExpression RegexDiff;

  bool ProcessLine()
    {
    if(!this->Line.empty() && this->Line[0] == '='
       && this->RegexDiff.find(this->Line))
      {
        CurrentPath = this->RegexDiff.match(1);
        AlreadyNotified = false;
      }
    else
      {
      if(!AlreadyNotified)
        {
        P4->DoModification(PathModified, CurrentPath);
        AlreadyNotified = true;
        }
      }
    return true;
    }
};

//----------------------------------------------------------------------------
cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
{
  std::map<std::string, cmCTestP4::User>::const_iterator it =
          Users.find(username);

  if(it == Users.end())
    {
    std::vector<char const*> p4_users;
    SetP4Options(p4_users);
    p4_users.push_back("users");
    p4_users.push_back("-m");
    p4_users.push_back("1");
    p4_users.push_back(username.c_str());
    p4_users.push_back(0);

    UserParser out(this, "users-out> ");
    OutputLogger err(this->Log, "users-err> ");
    RunChild(&p4_users[0], &out, &err);

    // The user should now be added to the map. Search again.
    it = Users.find(username);
    if(it == Users.end())
      {
      return cmCTestP4::User();
      }
    }

  return it->second;
}

//----------------------------------------------------------------------------
/* Commit format:

Change 1111111 by user@client on 2013/09/26 11:50:36

        text
        text

Affected files ...

... //path/to/file#rev edit
... //path/to/file#rev add
... //path/to/file#rev delete
... //path/to/file#rev integrate
*/
class cmCTestP4::DescribeParser: public cmCTestVC::LineParser
{
public:
  DescribeParser(cmCTestP4* p4, const char* prefix):
      LineParser('\n', false), P4(p4), Section(SectionHeader)
    {
    this->SetLog(&P4->Log, prefix);
    this->RegexHeader.compile("^Change ([0-9]+) by (.+)@(.+) on (.*)$");
    this->RegexDiff.compile("^\\.\\.\\. (.*)#[0-9]+ ([^ ]+)$");
    }
private:
  cmsys::RegularExpression RegexHeader;
  cmsys::RegularExpression RegexDiff;
  cmCTestP4* P4;

  typedef cmCTestP4::Revision Revision;
  typedef cmCTestP4::Change Change;
  std::vector<Change> Changes;
  enum SectionType { SectionHeader, SectionBody, SectionDiffHeader,
                     SectionDiff, SectionCount };
  SectionType Section;
  Revision Rev;

  virtual bool ProcessLine()
    {
    if(this->Line.empty())
      {
      this->NextSection();
      }
    else
      {
      switch(this->Section)
        {
        case SectionHeader:     this->DoHeaderLine(); break;
        case SectionBody:       this->DoBodyLine(); break;
        case SectionDiffHeader: break; // nothing to do
        case SectionDiff:       this->DoDiffLine(); break;
        case SectionCount:      break; // never happens
        }
      }
      return true;
      }

  void NextSection()
    {
    if(this->Section == SectionDiff)
    {
      this->P4->DoRevision(this->Rev, this->Changes);
      this->Rev = Revision();
    }

    this->Section = SectionType((this->Section+1) % SectionCount);
    }

  void DoHeaderLine()
    {
    if(this->RegexHeader.find(this->Line))
      {
      this->Rev.Rev = this->RegexHeader.match(1);
      this->Rev.Date = this->RegexHeader.match(4);

      cmCTestP4::User user = P4->GetUserData(this->RegexHeader.match(2));
      this->Rev.Author = user.Name;
      this->Rev.EMail = user.EMail;

      this->Rev.Committer = this->Rev.Author;
      this->Rev.CommitterEMail = this->Rev.EMail;
      this->Rev.CommitDate = this->Rev.Date;
      }
    }

  void DoBodyLine()
    {
    if(this->Line[0] == '\t')
      {
      this->Rev.Log += this->Line.substr(1);
      }
    this->Rev.Log += "\n";
    }

  void DoDiffLine()
    {
    if(this->RegexDiff.find(this->Line))
    {
    Change change;
    std::string Path = this->RegexDiff.match(1);
    if(Path.length() > 2 && Path[0] == '/' && Path[1] == '/')
      {
      size_t found = Path.find('/', 2);
      if(found != std::string::npos)
        {
        Path = Path.substr(found + 1);
        }
      }

    change.Path = Path;
    std::string action = this->RegexDiff.match(2);

    if(action == "add")
      {
      change.Action = 'A';
      }
    else if(action == "delete")
      {
      change.Action = 'D';
      }
    else if(action == "edit" || action == "integrate")
      {
      change.Action = 'M';
      }

    Changes.push_back(change);
    }
  }
};

//----------------------------------------------------------------------------
void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions)
{
  if(P4Options.empty())
    {
    const char* p4 = this->CommandLineTool.c_str();
    P4Options.push_back(p4);

    //The CTEST_P4_CLIENT variable sets the P4 client used when issuing
    //Perforce commands, if it's different from the default one.
    std::string client = this->CTest->GetCTestConfiguration("P4Client");
    if(!client.empty())
      {
      P4Options.push_back("-c");
      P4Options.push_back(client);
      }

    //Set the message language to be English, in case the P4 admin
    //has localized them
    P4Options.push_back("-L");
    P4Options.push_back("en");

    //The CTEST_P4_OPTIONS variable adds additional Perforce command line
    //options before the main command
    std::string opts = this->CTest->GetCTestConfiguration("P4Options");
    std::vector<std::string> args =
            cmSystemTools::ParseArguments(opts.c_str());

    P4Options.insert(P4Options.end(), args.begin(), args.end());
    }

  CommandOptions.clear();
  for(std::vector<std::string>::iterator i = P4Options.begin();
      i != P4Options.end(); ++i)
    {
    CommandOptions.push_back(i->c_str());
    }
}

//----------------------------------------------------------------------------
std::string cmCTestP4::GetWorkingRevision()
{
  std::vector<char const*> p4_identify;
  SetP4Options(p4_identify);

  p4_identify.push_back("changes");
  p4_identify.push_back("-m");
  p4_identify.push_back("1");
  p4_identify.push_back("-t");

  std::string source = this->SourceDirectory + "/...#have";
  p4_identify.push_back(source.c_str());
  p4_identify.push_back(0);

  std::string rev;
  IdentifyParser out(this, "p4_changes-out> ", rev);
  OutputLogger err(this->Log, "p4_changes-err> ");

  bool result = RunChild(&p4_identify[0], &out, &err);

  // If there was a problem contacting the server return "<unknown>"
  if(!result)
    {
    return "<unknown>";
    }

  if(rev.empty())
    {
    return "0";
    }
  else
    {
    return rev;
    }
}

//----------------------------------------------------------------------------
void cmCTestP4::NoteOldRevision()
{
  this->OldRevision = this->GetWorkingRevision();

  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
             << this->OldRevision << "\n");
  this->PriorRev.Rev = this->OldRevision;
}

//----------------------------------------------------------------------------
void cmCTestP4::NoteNewRevision()
{
  this->NewRevision = this->GetWorkingRevision();

  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
             << this->NewRevision << "\n");
}

//----------------------------------------------------------------------------
void cmCTestP4::LoadRevisions()
{
  std::vector<char const*> p4_changes;
  SetP4Options(p4_changes);

  // Use 'p4 changes ...@old,new' to get a list of changelists
  std::string range = this->SourceDirectory + "/...";

  // If any revision is unknown it means we couldn't contact the server.
  // Do not process updates
  if(this->OldRevision == "<unknown>" || this->NewRevision == "<unknown>")
    {
    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   At least one of the revisions "
               << "is unknown. No repository changes will be reported.\n");
    return;
    }

  range.append("@").append(this->OldRevision)
       .append(",").append(this->NewRevision);

  p4_changes.push_back("changes");
  p4_changes.push_back(range.c_str());
  p4_changes.push_back(0);

  ChangesParser out(this, "p4_changes-out> ");
  OutputLogger err(this->Log, "p4_changes-err> ");

  ChangeLists.clear();
  this->RunChild(&p4_changes[0], &out, &err);

  if(ChangeLists.empty())
      return;

  //p4 describe -s ...@1111111,2222222
  std::vector<char const*> p4_describe;
  for(std::vector<std::string>::reverse_iterator i = ChangeLists.rbegin();
      i != ChangeLists.rend(); ++i)
    {
    SetP4Options(p4_describe);
    p4_describe.push_back("describe");
    p4_describe.push_back("-s");
    p4_describe.push_back(i->c_str());
    p4_describe.push_back(0);

    DescribeParser outDescribe(this, "p4_describe-out> ");
    OutputLogger errDescribe(this->Log, "p4_describe-err> ");
    this->RunChild(&p4_describe[0], &outDescribe, &errDescribe);
    }
}

//----------------------------------------------------------------------------
void cmCTestP4::LoadModifications()
{
  std::vector<char const*> p4_diff;
  SetP4Options(p4_diff);

  p4_diff.push_back("diff");

  //Ideally we would use -Od but not all clients support it
  p4_diff.push_back("-dn");
  std::string source = this->SourceDirectory + "/...";
  p4_diff.push_back(source.c_str());
  p4_diff.push_back(0);

  DiffParser out(this, "p4_diff-out> ");
  OutputLogger err(this->Log, "p4_diff-err> ");
  this->RunChild(&p4_diff[0], &out, &err);
}

//----------------------------------------------------------------------------
bool cmCTestP4::UpdateCustom(const std::string& custom)
{
  std::vector<std::string> p4_custom_command;
  cmSystemTools::ExpandListArgument(custom, p4_custom_command, true);

  std::vector<char const*> p4_custom;
  for(std::vector<std::string>::const_iterator
        i = p4_custom_command.begin(); i != p4_custom_command.end(); ++i)
    {
    p4_custom.push_back(i->c_str());
    }
  p4_custom.push_back(0);

  OutputLogger custom_out(this->Log, "p4_customsync-out> ");
  OutputLogger custom_err(this->Log, "p4_customsync-err> ");

  return this->RunUpdateCommand(&p4_custom[0], &custom_out, &custom_err);
}

//----------------------------------------------------------------------------
bool cmCTestP4::UpdateImpl()
{
  std::string custom = this->CTest->GetCTestConfiguration("P4UpdateCustom");
  if(!custom.empty())
    {
    return this->UpdateCustom(custom);
    }

  // If we couldn't get a revision number before updating, abort.
  if(this->OldRevision == "<unknown>")
    {
    this->UpdateCommandLine = "Unknown current revision";
    cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown current revision\n");
    return false;
    }

  std::vector<char const*> p4_sync;
  SetP4Options(p4_sync);

  p4_sync.push_back("sync");

  // Get user-specified update options.
  std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
  if(opts.empty())
    {
    opts = this->CTest->GetCTestConfiguration("P4UpdateOptions");
    }
  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
  for(std::vector<std::string>::const_iterator ai = args.begin();
      ai != args.end(); ++ai)
    {
    p4_sync.push_back(ai->c_str());
    }

  std::string source = this->SourceDirectory + "/...";

  // Specify the start time for nightly testing.
  if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
    {
    std::string date = this->GetNightlyTime();
    //CTest reports the date as YYYY-MM-DD, Perforce needs it as YYYY/MM/DD
    std::replace(date.begin(), date.end(), '-', '/');

    //Revision specification: /...@"YYYY/MM/DD HH:MM:SS"
    source.append("@\"").append(date).append("\"");
    }

  p4_sync.push_back(source.c_str());
  p4_sync.push_back(0);

  OutputLogger out(this->Log, "p4_sync-out> ");
  OutputLogger err(this->Log, "p4_sync-err> ");

  return this->RunUpdateCommand(&p4_sync[0], &out, &err);
}