src/applications/diffusion/herald/HeraldCommitAdapter.php

   1 <?php
   2
   3 final class HeraldCommitAdapter
   4   extends HeraldAdapter
   5   implements HarbormasterBuildableAdapterInterface {
   6
   7   protected $diff;
   8   protected $revision;
   9
  10   protected $commit;
  11   private $commitDiff;
  12
  13   protected $affectedPaths;
  14   protected $affectedRevision;
  15   protected $affectedPackages;
  16   protected $auditNeededPackages;
  17
  18   private $buildRequests = array();
  19
  20   public function getAdapterApplicationClass() {
  21     return 'PhabricatorDiffusionApplication';
  22   }
  23
  24   protected function newObject() {
  25     return new PhabricatorRepositoryCommit();
  26   }
  27
  28   public function isTestAdapterForObject($object) {
  29     return ($object instanceof PhabricatorRepositoryCommit);
  30   }
  31
  32   public function getAdapterTestDescription() {
  33     return pht(
  34       'Test rules which run after a commit is discovered and imported.');
  35   }
  36
  37   public function newTestAdapter(PhabricatorUser $viewer, $object) {
  38     return id(clone $this)
  39       ->setObject($object);
  40   }
  41
  42   protected function initializeNewAdapter() {
  43     $this->commit = $this->newObject();
  44   }
  45
  46   public function setObject($object) {
  47     $viewer = $this->getViewer();
  48     $commit_phid = $object->getPHID();
  49
  50     $commit = id(new DiffusionCommitQuery())
  51       ->setViewer($viewer)
  52       ->withPHIDs(array($commit_phid))
  53       ->needCommitData(true)
  54       ->needIdentities(true)
  55       ->needAuditRequests(true)
  56       ->executeOne();
  57     if (!$commit) {
  58       throw new Exception(
  59         pht(
  60           'Failed to reload commit ("%s") to fetch commit data.',
  61           $commit_phid));
  62     }
  63
  64     $this->commit = $commit;
  65
  66     return $this;
  67   }
  68
  69   public function getObject() {
  70     return $this->commit;
  71   }
  72
  73   public function getAdapterContentType() {
  74     return 'commit';
  75   }
  76
  77   public function getAdapterContentName() {
  78     return pht('Commits');
  79   }
  80
  81   public function getAdapterContentDescription() {
  82     return pht(
  83       "React to new commits appearing in tracked repositories.\n".
  84       "Commit rules can send email, flag commits, trigger audits, ".
  85       "and run build plans.");
  86   }
  87
  88   public function supportsRuleType($rule_type) {
  89     switch ($rule_type) {
  90       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
  91       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
  92       case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
  93         return true;
  94       default:
  95         return false;
  96     }
  97   }
  98
  99   public function canTriggerOnObject($object) {
 100     if ($object instanceof PhabricatorRepository) {
 101       return true;
 102     }
 103     if ($object instanceof PhabricatorProject) {
 104       return true;
 105     }
 106     return false;
 107   }
 108
 109   public function getTriggerObjectPHIDs() {
 110     $project_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
 111
 112     $repository_phid = $this->getRepository()->getPHID();
 113     $commit_phid = $this->getObject()->getPHID();
 114
 115     $phids = array();
 116     $phids[] = $commit_phid;
 117     $phids[] = $repository_phid;
 118
 119     // NOTE: This is projects for the repository, not for the commit. When
 120     // Herald evaluates, commits normally can not have any project tags yet.
 121     $repository_project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
 122       $repository_phid,
 123       $project_type);
 124     foreach ($repository_project_phids as $phid) {
 125       $phids[] = $phid;
 126     }
 127
 128     $phids = array_unique($phids);
 129     $phids = array_values($phids);
 130
 131     return $phids;
 132   }
 133
 134   public function explainValidTriggerObjects() {
 135     return pht('This rule can trigger for **repositories** and **projects**.');
 136   }
 137
 138   public function getHeraldName() {
 139     return $this->commit->getMonogram();
 140   }
 141
 142   public function loadAffectedPaths() {
 143     $viewer = $this->getViewer();
 144
 145     if ($this->affectedPaths === null) {
 146       $result = PhabricatorOwnerPathQuery::loadAffectedPaths(
 147         $this->getRepository(),
 148         $this->commit,
 149         $viewer);
 150       $this->affectedPaths = $result;
 151     }
 152
 153     return $this->affectedPaths;
 154   }
 155
 156   public function loadAffectedPackages() {
 157     if ($this->affectedPackages === null) {
 158       $packages = PhabricatorOwnersPackage::loadAffectedPackages(
 159         $this->getRepository(),
 160         $this->loadAffectedPaths());
 161       $this->affectedPackages = $packages;
 162     }
 163     return $this->affectedPackages;
 164   }
 165
 166   public function loadAuditNeededPackages() {
 167     if ($this->auditNeededPackages === null) {
 168       $status_arr = array(
 169         PhabricatorAuditRequestStatus::AUDIT_REQUIRED,
 170         PhabricatorAuditRequestStatus::CONCERNED,
 171       );
 172       $requests = id(new PhabricatorRepositoryAuditRequest())
 173           ->loadAllWhere(
 174         'commitPHID = %s AND auditStatus IN (%Ls)',
 175         $this->commit->getPHID(),
 176         $status_arr);
 177       $this->auditNeededPackages = $requests;
 178     }
 179     return $this->auditNeededPackages;
 180   }
 181
 182   public function loadDifferentialRevision() {
 183     if ($this->affectedRevision === null) {
 184       $viewer = $this->getViewer();
 185
 186       // NOTE: The viewer here is omnipotent, which means that Herald discloses
 187       // some information users do not normally have access to when rules load
 188       // the revision related to a commit. See D20468.
 189
 190       // A user who wants to learn about "Dxyz" can write a Herald rule which
 191       // uses all the "Related revision..." fields, then push a commit which
 192       // contains "Differential Revision: Dxyz" in the message to make Herald
 193       // evaluate the commit with "Dxyz" as the related revision.
 194
 195       // At time of writing, this commit will link to the revision and the
 196       // transcript for the commit will disclose some information about the
 197       // revision (like reviewers, subscribers, and build status) which the
 198       // commit author could not otherwise see.
 199
 200       // For now, we just accept this. The disclosures are relatively
 201       // uninteresting and you have to jump through a lot of hoops (and leave
 202       // a lot of evidence) to get this information.
 203
 204       $revision = DiffusionCommitRevisionQuery::loadRevisionForCommit(
 205         $viewer,
 206         $this->getObject());
 207       if ($revision) {
 208         $this->affectedRevision = $revision;
 209       } else {
 210         $this->affectedRevision = false;
 211       }
 212     }
 213
 214     return $this->affectedRevision;
 215   }
 216
 217   public static function getEnormousByteLimit() {
 218     return 256 * 1024 * 1024; // 256MB. See T13142 and T13143.
 219   }
 220
 221   public static function getEnormousTimeLimit() {
 222     return 60 * 15; // 15 Minutes
 223   }
 224
 225   private function loadCommitDiff() {
 226     $viewer = $this->getViewer();
 227
 228     $byte_limit = self::getEnormousByteLimit();
 229     $time_limit = self::getEnormousTimeLimit();
 230
 231     $diff_info = $this->callConduit(
 232       'diffusion.rawdiffquery',
 233       array(
 234         'commit' => $this->commit->getCommitIdentifier(),
 235         'timeout' => $time_limit,
 236         'byteLimit' => $byte_limit,
 237         'linesOfContext' => 0,
 238       ));
 239
 240     if ($diff_info['tooHuge']) {
 241       throw new Exception(
 242         pht(
 243           'The raw text of this change is enormous (larger than %s byte(s)). '.
 244           'Herald can not process it.',
 245           new PhutilNumber($byte_limit)));
 246     }
 247
 248     if ($diff_info['tooSlow']) {
 249       throw new Exception(
 250         pht(
 251           'The raw text of this change took too long to process (longer '.
 252           'than %s second(s)). Herald can not process it.',
 253           new PhutilNumber($time_limit)));
 254     }
 255
 256     $file_phid = $diff_info['filePHID'];
 257     $diff_file = id(new PhabricatorFileQuery())
 258       ->setViewer($viewer)
 259       ->withPHIDs(array($file_phid))
 260       ->executeOne();
 261     if (!$diff_file) {
 262       throw new Exception(
 263         pht(
 264           'Failed to load diff ("%s") for this change.',
 265           $file_phid));
 266     }
 267
 268     $raw = $diff_file->loadFileData();
 269
 270     $parser = new ArcanistDiffParser();
 271     $changes = $parser->parseDiff($raw);
 272
 273     $diff = DifferentialDiff::newEphemeralFromRawChanges(
 274       $changes);
 275     return $diff;
 276   }
 277
 278   public function isDiffEnormous() {
 279     $this->loadDiffContent('*');
 280     return ($this->commitDiff instanceof Exception);
 281   }
 282
 283   public function loadDiffContent($type) {
 284     if ($this->commitDiff === null) {
 285       try {
 286         $this->commitDiff = $this->loadCommitDiff();
 287       } catch (Exception $ex) {
 288         $this->commitDiff = $ex;
 289         phlog($ex);
 290       }
 291     }
 292
 293     if ($this->commitDiff instanceof Exception) {
 294       $ex = $this->commitDiff;
 295       $ex_class = get_class($ex);
 296       $ex_message = pht('Failed to load changes: %s', $ex->getMessage());
 297
 298       return array(
 299         '<'.$ex_class.'>' => $ex_message,
 300       );
 301     }
 302
 303     $changes = $this->commitDiff->getChangesets();
 304
 305     $result = array();
 306     foreach ($changes as $change) {
 307       $lines = array();
 308       foreach ($change->getHunks() as $hunk) {
 309         switch ($type) {
 310           case '-':
 311             $lines[] = $hunk->makeOldFile();
 312             break;
 313           case '+':
 314             $lines[] = $hunk->makeNewFile();
 315             break;
 316           case '*':
 317             $lines[] = $hunk->makeChanges();
 318             break;
 319           default:
 320             throw new Exception(pht("Unknown content selection '%s'!", $type));
 321         }
 322       }
 323       $result[$change->getFilename()] = implode("\n", $lines);
 324     }
 325
 326     return $result;
 327   }
 328
 329   public function loadIsMergeCommit() {
 330     $parents = $this->callConduit(
 331       'diffusion.commitparentsquery',
 332       array(
 333         'commit' => $this->getObject()->getCommitIdentifier(),
 334       ));
 335
 336     return (count($parents) > 1);
 337   }
 338
 339   private function callConduit($method, array $params) {
 340     $viewer = $this->getViewer();
 341
 342     $drequest = DiffusionRequest::newFromDictionary(
 343       array(
 344         'user' => $viewer,
 345         'repository' => $this->getRepository(),
 346         'commit' => $this->commit->getCommitIdentifier(),
 347       ));
 348
 349     return DiffusionQuery::callConduitWithDiffusionRequest(
 350       $viewer,
 351       $drequest,
 352       $method,
 353       $params);
 354   }
 355
 356   private function getRepository() {
 357     return $this->getObject()->getRepository();
 358   }
 359
 360   public function getAuthorPHID() {
 361     return $this->getObject()->getEffectiveAuthorPHID();
 362   }
 363
 364   public function getCommitterPHID() {
 365     $commit = $this->getObject();
 366
 367     if ($commit->hasCommitterIdentity()) {
 368       $identity = $commit->getCommitterIdentity();
 369       return $identity->getCurrentEffectiveUserPHID();
 370     }
 371
 372     return null;
 373   }
 374
 375
 376 /* -(  HarbormasterBuildableAdapterInterface  )------------------------------ */
 377
 378
 379   public function getHarbormasterBuildablePHID() {
 380     return $this->getObject()->getPHID();
 381   }
 382
 383   public function getHarbormasterContainerPHID() {
 384     return $this->getObject()->getRepository()->getPHID();
 385   }
 386
 387   public function getQueuedHarbormasterBuildRequests() {
 388     return $this->buildRequests;
 389   }
 390
 391   public function queueHarbormasterBuildRequest(
 392     HarbormasterBuildRequest $request) {
 393     $this->buildRequests[] = $request;
 394   }
 395
 396 }