No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/patches/101.heraldruleapplied.sql b/resources/sql/patches/101.heraldruleapplied.sql
	new file mode 100644
	index 0000000000..30c7a1a8ad
	--- /dev/null
	+++ b/resources/sql/patches/101.heraldruleapplied.sql
	@@ -0,0 +1,2 @@
	+ALTER TABLE phabricator_herald.herald_ruleapplied
	+ ADD KEY (phid);
	diff --git a/src/applications/herald/controller/test/HeraldTestConsoleController.php b/src/applications/herald/controller/test/HeraldTestConsoleController.php
	index a8eb194e79..da94aa46d9 100644
	--- a/src/applications/herald/controller/test/HeraldTestConsoleController.php
	+++ b/src/applications/herald/controller/test/HeraldTestConsoleController.php
	@@ -1,149 +1,150 @@
	<?php

	/*
	- * Copyright 2011 Facebook, Inc.
	+ * Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class HeraldTestConsoleController extends HeraldController {

	public function getFilter() {
	return 'test';
	}

	public function processRequest() {

	$request = $this->getRequest();
	$user = $request->getUser();

	$request = $this->getRequest();

	$object_name = trim($request->getStr('object_name'));

	$e_name = true;
	$errors = array();
	if ($request->isFormPost()) {
	if (!$object_name) {
	$e_name = 'Required';
	$errors[] = 'An object name is required.';
	}

	if (!$errors) {
	$matches = null;
	$object = null;
	if (preg_match('/^D(\d+)$/', $object_name, $matches)) {
	$object = id(new DifferentialRevision())->load($matches[1]);
	if (!$object) {
	$e_name = 'Invalid';
	$errors[] = 'No Differential Revision with that ID exists.';
	}
	} else if (preg_match('/^r([A-Z]+)(\w+)$/', $object_name, $matches)) {
	$repo = id(new PhabricatorRepository())->loadOneWhere(
	'callsign = %s',
	$matches[1]);
	if (!$repo) {
	$e_name = 'Invalid';
	$errors[] = 'There is no repository with the callsign '.
	$matches[1].'.';
	}
	$commit = id(new PhabricatorRepositoryCommit())->loadOneWhere(
	'repositoryID = %d AND commitIdentifier = %s',
	$repo->getID(),
	$matches[2]);
	if (!$commit) {
	$e_name = 'Invalid';
	$errors[] = 'There is no commit with that identifier.';
	}
	$object = $commit;
	} else {
	$e_name = 'Invalid';
	$errors[] = 'This object name is not recognized.';
	}

	if (!$errors) {
	if ($object instanceof DifferentialRevision) {
	$adapter = new HeraldDifferentialRevisionAdapter(
	$object,
	$object->loadActiveDiff());
	} else if ($object instanceof PhabricatorRepositoryCommit) {
	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$object->getID());
	$adapter = new HeraldCommitAdapter(
	$repo,
	$object,
	$data);
	} else {
	throw new Exception("Can not build adapter for object!");
	}

	$rules = HeraldRule::loadAllByContentTypeWithFullData(
	- $adapter->getHeraldTypeName());
	+ $adapter->getHeraldTypeName(),
	+ $object->getPHID());

	$engine = new HeraldEngine();
	$effects = $engine->applyRules($rules, $adapter);

	$dry_run = new HeraldDryRunAdapter();
	$engine->applyEffects($effects, $dry_run);

	$xscript = $engine->getTranscript();

	return id(new AphrontRedirectResponse())
	->setURI('/herald/transcript/'.$xscript->getID().'/');
	}
	}
	}

	if ($errors) {
	$error_view = new AphrontErrorView();
	$error_view->setTitle('Form Errors');
	$error_view->setErrors($errors);
	} else {
	$error_view = null;
	}

	$form = id(new AphrontFormView())
	->setUser($user)
	->appendChild(
	'<p class="aphront-form-instructions">Enter an object to test rules '.
	'for, like a Diffusion commit (e.g., <tt>rX123</tt>) or a '.
	'Differential revision (e.g., <tt>D123</tt>). You will be shown the '.
	'results of a dry run on the object.</p>')
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel('Object Name')
	->setName('object_name')
	->setError($e_name)
	->setValue($object_name))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue('Test Rules'));

	$panel = new AphrontPanelView();
	$panel->setHeader('Test Herald Rules');
	$panel->setWidth(AphrontPanelView::WIDTH_FULL);
	$panel->appendChild($form);

	return $this->buildStandardPageResponse(
	array(
	$error_view,
	$panel,
	),
	array(
	'title' => 'Test Console',
	'tab' => 'test',
	));
	}

	}
	diff --git a/src/applications/herald/engine/engine/HeraldEngine.php b/src/applications/herald/engine/engine/HeraldEngine.php
	index 6ef84673a7..9426d8afd1 100644
	--- a/src/applications/herald/engine/engine/HeraldEngine.php
	+++ b/src/applications/herald/engine/engine/HeraldEngine.php
	@@ -1,482 +1,484 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class HeraldEngine {

	protected $rules = array();
	protected $results = array();
	protected $stack = array();
	protected $activeRule = null;

	protected $fieldCache = array();
	protected $object = null;

	public static function loadAndApplyRules(HeraldObjectAdapter $object) {
	$content_type = $object->getHeraldTypeName();
	- $rules = HeraldRule::loadAllByContentTypeWithFullData($content_type);
	+ $rules = HeraldRule::loadAllByContentTypeWithFullData(
	+ $content_type,
	+ $object->getPHID());

	$engine = new HeraldEngine();
	$effects = $engine->applyRules($rules, $object);
	$engine->applyEffects($effects, $object);

	return $engine->getTranscript();
	}

	public function applyRules(array $rules, HeraldObjectAdapter $object) {
	$t_start = microtime(true);

	$rules = mpull($rules, null, 'getID');

	$this->transcript = new HeraldTranscript();
	$this->transcript->setObjectPHID((string)$object->getPHID());
	$this->fieldCache = array();
	$this->results = array();
	$this->rules = $rules;
	$this->object = $object;

	$effects = array();
	foreach ($rules as $id => $rule) {
	$this->stack = array();
	try {
	if (($rule->getRepetitionPolicy() ==
	HeraldRepetitionPolicyConfig::FIRST) &&
	$rule->getRuleApplied($object->getPHID())) {
	// This rule is only supposed to be applied a single time, and it's
	// aleady been applied, so this is an automatic failure.
	$xscript = id(new HeraldRuleTranscript())
	->setRuleID($id)
	->setResult(false)
	->setRuleName($rule->getName())
	->setRuleOwner($rule->getAuthorPHID())
	->setReason(
	"This rule is only supposed to be repeated a single time, ".
	"and it has already been applied."
	);
	$this->transcript->addRuleTranscript($xscript);
	$rule_matches = false;
	} else {
	$rule_matches = $this->doesRuleMatch($rule, $object);
	}
	} catch (HeraldRecursiveConditionsException $ex) {
	$names = array();
	foreach ($this->stack as $rule_id => $ignored) {
	$names[] = '"'.$rules[$rule_id]->getName().'"';
	}
	$names = implode(', ', $names);
	foreach ($this->stack as $rule_id => $ignored) {
	$xscript = new HeraldRuleTranscript();
	$xscript->setRuleID($rule_id);
	$xscript->setResult(false);
	$xscript->setReason(
	"Rules {$names} are recursively dependent upon one another! ".
	"Don't do this! You have formed an unresolvable cycle in the ".
	"dependency graph!");
	$xscript->setRuleName($rules[$rule_id]->getName());
	$xscript->setRuleOwner($rules[$rule_id]->getAuthorPHID());
	$this->transcript->addRuleTranscript($xscript);
	}
	$rule_matches = false;
	}
	$this->results[$id] = $rule_matches;

	if ($rule_matches) {
	foreach ($this->getRuleEffects($rule, $object) as $effect) {
	$effects[] = $effect;
	}
	}
	}

	$object_transcript = new HeraldObjectTranscript();
	$object_transcript->setPHID($object->getPHID());
	$object_transcript->setName($object->getHeraldName());
	$object_transcript->setType($object->getHeraldTypeName());
	$object_transcript->setFields($this->fieldCache);

	$this->transcript->setObjectTranscript($object_transcript);

	$t_end = microtime(true);

	$this->transcript->setDuration($t_end - $t_start);

	return $effects;
	}

	public function applyEffects(array $effects, HeraldObjectAdapter $object) {
	$this->transcript->setDryRun($object instanceof HeraldDryRunAdapter);

	$xscripts = $object->applyHeraldEffects($effects);
	foreach ($xscripts as $apply_xscript) {
	if (!($apply_xscript instanceof HeraldApplyTranscript)) {
	throw new Exception(
	"Heraldable must return HeraldApplyTranscripts from ".
	"applyHeraldEffect().");
	}
	$this->transcript->addApplyTranscript($apply_xscript);
	}

	if (!$this->transcript->getDryRun()) {
	// Mark all the rules that have had their effects applied as having been
	// executed for the current object.
	$rule_ids = mpull($xscripts, 'getRuleID');
	foreach ($rule_ids as $rule_id) {
	if (!$rule_id) {
	// Some apply transcripts are purely informational and not associated
	// with a rule, e.g. carryover emails from earlier revisions.
	continue;
	}
	HeraldRule::saveRuleApplied($rule_id, $object->getPHID());
	}
	}
	}

	public function getTranscript() {
	$this->transcript->save();
	return $this->transcript;
	}

	protected function doesRuleMatch(
	HeraldRule $rule,
	HeraldObjectAdapter $object) {

	$id = $rule->getID();

	if (isset($this->results[$id])) {
	// If we've already evaluated this rule because another rule depends
	// on it, we don't need to reevaluate it.
	return $this->results[$id];
	}

	if (isset($this->stack[$id])) {
	// We've recursed, fail all of the rules on the stack. This happens when
	// there's a dependency cycle with "Rule conditions match for rule ..."
	// conditions.
	foreach ($this->stack as $rule_id => $ignored) {
	$this->results[$rule_id] = false;
	}
	throw new HeraldRecursiveConditionsException();
	}

	$this->stack[$id] = true;

	$all = $rule->getMustMatchAll();

	$conditions = $rule->getConditions();

	$result = null;

	$local_version = id(new HeraldRule())->getConfigVersion();
	if ($rule->getConfigVersion() > $local_version) {
	$reason = "Rule could not be processed, it was created with a newer ".
	"version of Herald.";
	$result = false;
	} else if (!$conditions) {
	$reason = "Rule failed automatically because it has no conditions.";
	$result = false;
	/* TOOD: Restore this in some form?
	} else if (!is_fb_employee($rule->getAuthorPHID())) {
	$reason = "Rule failed automatically because its owner is not an ".
	"active employee.";
	$result = false;
	*/
	} else {
	foreach ($conditions as $condition) {
	$match = $this->doesConditionMatch($rule, $condition, $object);

	if (!$all && $match) {
	$reason = "Any condition matched.";
	$result = true;
	break;
	}

	if ($all && !$match) {
	$reason = "Not all conditions matched.";
	$result = false;
	break;
	}
	}

	if ($result === null) {
	if ($all) {
	$reason = "All conditions matched.";
	$result = true;
	} else {
	$reason = "No conditions matched.";
	$result = false;
	}
	}
	}

	$rule_transcript = new HeraldRuleTranscript();
	$rule_transcript->setRuleID($rule->getID());
	$rule_transcript->setResult($result);
	$rule_transcript->setReason($reason);
	$rule_transcript->setRuleName($rule->getName());
	$rule_transcript->setRuleOwner($rule->getAuthorPHID());

	$this->transcript->addRuleTranscript($rule_transcript);

	return $result;
	}

	protected function doesConditionMatch(
	HeraldRule $rule,
	HeraldCondition $condition,
	HeraldObjectAdapter $object) {

	$object_value = $this->getConditionObjectValue($condition, $object);
	$test_value = $condition->getValue();

	$cond = $condition->getFieldCondition();

	$transcript = new HeraldConditionTranscript();
	$transcript->setRuleID($rule->getID());
	$transcript->setConditionID($condition->getID());
	$transcript->setFieldName($condition->getFieldName());
	$transcript->setCondition($cond);
	$transcript->setTestValue($test_value);

	$result = null;
	switch ($cond) {
	case HeraldConditionConfig::CONDITION_CONTAINS:
	// "Contains" can take an array of strings, as in "Any changed
	// filename" for diffs.
	foreach ((array)$object_value as $value) {
	$result = (stripos($value, $test_value) !== false);
	if ($result) {
	break;
	}
	}
	break;
	case HeraldConditionConfig::CONDITION_NOT_CONTAINS:
	$result = (stripos($object_value, $test_value) === false);
	break;
	case HeraldConditionConfig::CONDITION_IS:
	$result = ($object_value == $test_value);
	break;
	case HeraldConditionConfig::CONDITION_IS_NOT:
	$result = ($object_value != $test_value);
	break;
	case HeraldConditionConfig::CONDITION_IS_ME:
	$result = ($object_value == $rule->getAuthorPHID());
	break;
	case HeraldConditionConfig::CONDITION_IS_NOT_ME:
	$result = ($object_value != $rule->getAuthorPHID());
	break;
	case HeraldConditionConfig::CONDITION_IS_ANY:
	$test_value = array_flip($test_value);
	$result = isset($test_value[$object_value]);
	break;
	case HeraldConditionConfig::CONDITION_IS_NOT_ANY:
	$test_value = array_flip($test_value);
	$result = !isset($test_value[$object_value]);
	break;
	case HeraldConditionConfig::CONDITION_INCLUDE_ALL:
	if (!is_array($object_value)) {
	$transcript->setNote('Object produced bad value!');
	$result = false;
	} else {
	$have = array_select_keys(array_flip($object_value),
	$test_value);
	$result = (count($have) == count($test_value));
	}
	break;
	case HeraldConditionConfig::CONDITION_INCLUDE_ANY:
	$result = (bool)array_select_keys(array_flip($object_value),
	$test_value);
	break;
	case HeraldConditionConfig::CONDITION_INCLUDE_NONE:
	$result = !array_select_keys(array_flip($object_value),
	$test_value);
	break;
	case HeraldConditionConfig::CONDITION_EXISTS:
	$result = (bool)$object_value;
	break;
	case HeraldConditionConfig::CONDITION_NOT_EXISTS:
	$result = !$object_value;
	break;
	case HeraldConditionConfig::CONDITION_REGEXP:
	foreach ((array)$object_value as $value) {
	$result = @preg_match($test_value, $value);
	if ($result === false) {
	$transcript->setNote(
	"Regular expression is not valid!");
	break;
	}
	if ($result) {
	break;
	}
	}
	$result = (bool)$result;
	break;
	case HeraldConditionConfig::CONDITION_REGEXP_PAIR:
	// Match a JSON-encoded pair of regular expressions against a
	// dictionary. The first regexp must match the dictionary key, and the
	// second regexp must match the dictionary value. If any key/value pair
	// in the dictionary matches both regexps, the condition is satisfied.
	$regexp_pair = json_decode($test_value, true);
	if (!is_array($regexp_pair)) {
	$result = false;
	$transcript->setNote("Regular expression pair is not valid JSON!");
	break;
	}
	if (count($regexp_pair) != 2) {
	$result = false;
	$transcript->setNote("Regular expression pair is not a pair!");
	break;
	}

	$key_regexp = array_shift($regexp_pair);
	$value_regexp = array_shift($regexp_pair);

	foreach ((array)$object_value as $key => $value) {
	$key_matches = @preg_match($key_regexp, $key);
	if ($key_matches === false) {
	$result = false;
	$transcript->setNote("First regular expression is invalid!");
	break 2;
	}
	if ($key_matches) {
	$value_matches = @preg_match($value_regexp, $value);
	if ($value_matches === false) {
	$result = false;
	$transcript->setNote("Second regular expression is invalid!");
	break 2;
	}
	if ($value_matches) {
	$result = true;
	break 2;
	}
	}
	}
	$result = false;
	break;
	case HeraldConditionConfig::CONDITION_RULE:
	case HeraldConditionConfig::CONDITION_NOT_RULE:

	$rule = idx($this->rules, $test_value);
	if (!$rule) {
	$transcript->setNote(
	"Condition references a rule which does not exist!");
	$result = false;
	} else {
	$is_not = ($cond == HeraldConditionConfig::CONDITION_NOT_RULE);
	$result = $this->doesRuleMatch($rule, $object);
	if ($is_not) {
	$result = !$result;
	}
	}
	break;
	default:
	throw new HeraldInvalidConditionException(
	"Unknown condition '{$cond}'.");
	}

	$transcript->setResult($result);

	$this->transcript->addConditionTranscript($transcript);

	return $result;
	}

	protected function getConditionObjectValue(
	HeraldCondition $condition,
	HeraldObjectAdapter $object) {

	$field = $condition->getFieldName();

	return $this->getObjectFieldValue($field);
	}

	public function getObjectFieldValue($field) {
	if (isset($this->fieldCache[$field])) {
	return $this->fieldCache[$field];
	}

	$result = null;
	switch ($field) {
	case HeraldFieldConfig::FIELD_RULE:
	$result = null;
	break;
	case HeraldFieldConfig::FIELD_TITLE:
	case HeraldFieldConfig::FIELD_BODY:
	case HeraldFieldConfig::FIELD_DIFF_FILE:
	case HeraldFieldConfig::FIELD_DIFF_CONTENT:
	// TODO: Type should be string.
	$result = $this->object->getHeraldField($field);
	break;
	case HeraldFieldConfig::FIELD_AUTHOR:
	case HeraldFieldConfig::FIELD_REPOSITORY:
	case HeraldFieldConfig::FIELD_MERGE_REQUESTER:
	// TODO: Type should be PHID.
	$result = $this->object->getHeraldField($field);
	break;
	case HeraldFieldConfig::FIELD_TAGS:
	case HeraldFieldConfig::FIELD_REVIEWER:
	case HeraldFieldConfig::FIELD_REVIEWERS:
	case HeraldFieldConfig::FIELD_CC:
	case HeraldFieldConfig::FIELD_DIFFERENTIAL_REVIEWERS:
	case HeraldFieldConfig::FIELD_DIFFERENTIAL_CCS:
	// TODO: Type should be list.
	$result = $this->object->getHeraldField($field);
	break;
	case HeraldFieldConfig::FIELD_AFFECTED_PACKAGE:
	case HeraldFieldConfig::FIELD_AFFECTED_PACKAGE_OWNER:
	case HeraldFieldConfig::FIELD_NEED_AUDIT_FOR_PACKAGE:
	$result = $this->object->getHeraldField($field);
	if (!is_array($result)) {
	throw new HeraldInvalidFieldException(
	"Value of field type {$field} is not an array!");
	}
	break;
	case HeraldFieldConfig::FIELD_DIFFERENTIAL_REVISION:
	// TODO: Type should be boolean I guess.
	$result = $this->object->getHeraldField($field);
	break;
	default:
	throw new HeraldInvalidConditionException(
	"Unknown field type '{$field}'!");
	}

	$this->fieldCache[$field] = $result;
	return $result;
	}

	protected function getRuleEffects(
	HeraldRule $rule,
	HeraldObjectAdapter $object) {

	$effects = array();
	foreach ($rule->getActions() as $action) {
	$effect = new HeraldEffect();
	$effect->setObjectPHID($object->getPHID());
	$effect->setAction($action->getAction());
	$effect->setTarget($action->getTarget());

	$effect->setRuleID($rule->getID());

	$name = $rule->getName();
	$id = $rule->getID();
	$effect->setReason(
	'Conditions were met for Herald rule "'.$name.'" (#'.$id.').');

	$effects[] = $effect;
	}
	return $effects;
	}

	}
	diff --git a/src/applications/herald/storage/rule/HeraldRule.php b/src/applications/herald/storage/rule/HeraldRule.php
	index bc1702a15f..4938fc318c 100644
	--- a/src/applications/herald/storage/rule/HeraldRule.php
	+++ b/src/applications/herald/storage/rule/HeraldRule.php
	@@ -1,187 +1,189 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class HeraldRule extends HeraldDAO {

	const TABLE_RULE_APPLIED = 'herald_ruleapplied';

	protected $name;
	protected $authorPHID;

	protected $contentType;
	protected $mustMatchAll;
	protected $repetitionPolicy;
	protected $ruleType;

	protected $configVersion = 8;

	private $ruleApplied = array(); // phids for which this rule has been applied

	- public static function loadAllByContentTypeWithFullData($content_type) {
	+ public static function loadAllByContentTypeWithFullData(
	+ $content_type,
	+ $object_phid) {
	+
	$rules = id(new HeraldRule())->loadAllWhere(
	'contentType = %s',
	$content_type);

	if (!$rules) {
	return array();
	}

	$rule_ids = mpull($rules, 'getID');

	$conditions = id(new HeraldCondition())->loadAllWhere(
	'ruleID in (%Ld)',
	$rule_ids);

	$actions = id(new HeraldAction())->loadAllWhere(
	'ruleID in (%Ld)',
	$rule_ids);

	$applied = queryfx_all(
	id(new HeraldRule())->establishConnection('r'),
	- 'SELECT * FROM %T WHERE ruleID in (%Ld)',
	- self::TABLE_RULE_APPLIED, $rule_ids
	- );
	+ 'SELECT * FROM %T WHERE phid = %s',
	+ self::TABLE_RULE_APPLIED,
	+ $object_phid);
	+ $applied = ipull($applied, null, 'ruleID');

	$conditions = mgroup($conditions, 'getRuleID');
	$actions = mgroup($actions, 'getRuleID');
	$applied = igroup($applied, 'ruleID');

	-
	foreach ($rules as $rule) {
	- $rule->attachAllRuleApplied(idx($applied, $rule->getID(), array()));
	+ $rule->setRuleApplied($object_phid, isset($applied[$rule->getID()]));
	+
	$rule->attachConditions(idx($conditions, $rule->getID(), array()));
	$rule->attachActions(idx($actions, $rule->getID(), array()));
	}

	return $rules;
	}

	public function getRuleApplied($phid) {
	- // defaults to false because (ruleID, phid) pairs not in the db imply
	- // a rule that's not been applied before
	- return idx($this->ruleApplied, $phid, false);
	+ if (idx($this->ruleApplied, $phid) === null) {
	+ throw new Exception("Call setRuleApplied() before getRuleApplied()!");
	+ }
	+ return $this->ruleApplied[$phid];
	}

	- public function setRuleApplied($phid) {
	- $this->ruleApplied[$phid] = true;
	+ public function setRuleApplied($phid, $applied) {
	+ $this->ruleApplied[$phid] = $applied;
	+ return $this;
	}

	- public function attachAllRuleApplied(array $applied) {
	- // turn array of array(ruleID, phid) into array of ruleID => true
	- $this->ruleApplied = array_fill_keys(ipull($applied, 'phid'), true);
	- }
	-
	public static function saveRuleApplied($rule_id, $phid) {
	queryfx(
	id(new HeraldRule())->establishConnection('w'),
	'INSERT IGNORE INTO %T (phid, ruleID) VALUES (%s, %d)',
	- self::TABLE_RULE_APPLIED, $phid, $rule_id
	- );
	+ self::TABLE_RULE_APPLIED,
	+ $phid,
	+ $rule_id);
	}

	public function loadConditions() {
	if (!$this->getID()) {
	return array();
	}
	return id(new HeraldCondition())->loadAllWhere(
	'ruleID = %d',
	$this->getID());
	}

	public function attachConditions(array $conditions) {
	$this->conditions = $conditions;
	return $this;
	}

	public function getConditions() {
	// TODO: validate conditions have been attached.
	return $this->conditions;
	}

	public function loadActions() {
	if (!$this->getID()) {
	return array();
	}
	return id(new HeraldAction())->loadAllWhere(
	'ruleID = %d',
	$this->getID());
	}

	public function attachActions(array $actions) {
	// TODO: validate actions have been attached.
	$this->actions = $actions;
	return $this;
	}

	public function getActions() {
	return $this->actions;
	}

	public function saveConditions(array $conditions) {
	return $this->saveChildren(
	id(new HeraldCondition())->getTableName(),
	$conditions);
	}

	public function saveActions(array $actions) {
	return $this->saveChildren(
	id(new HeraldAction())->getTableName(),
	$actions);
	}

	protected function saveChildren($table_name, array $children) {
	if (!$this->getID()) {
	throw new Exception("Save rule before saving children.");
	}

	foreach ($children as $child) {
	$child->setRuleID($this->getID());
	}

	// TODO:
	// $this->openTransaction();
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	$table_name,
	$this->getID());
	foreach ($children as $child) {
	$child->save();
	}
	// $this->saveTransaction();
	}

	public function delete() {

	// TODO:
	// $this->openTransaction();
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	id(new HeraldCondition())->getTableName(),
	$this->getID());
	queryfx(
	$this->establishConnection('w'),
	'DELETE FROM %T WHERE ruleID = %d',
	id(new HeraldAction())->getTableName(),
	$this->getID());
	parent::delete();
	// $this->saveTransaction();
	}

	}
	diff --git a/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
	index 3ba9992f49..acf34dfa68 100644
	--- a/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
	+++ b/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
	@@ -1,139 +1,140 @@
	<?php

	/*
	- * Copyright 2011 Facebook, Inc.
	+ * Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class PhabricatorRepositoryCommitHeraldWorker
	extends PhabricatorRepositoryCommitParserWorker {

	public function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	if ($repository->getDetail('herald-disabled')) {
	return;
	}

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());

	$rules = HeraldRule::loadAllByContentTypeWithFullData(
	- HeraldContentTypeConfig::CONTENT_TYPE_COMMIT);
	+ HeraldContentTypeConfig::CONTENT_TYPE_COMMIT,
	+ $commit->getPHID());

	$adapter = new HeraldCommitAdapter(
	$repository,
	$commit,
	$data);
	$engine = new HeraldEngine();

	$effects = $engine->applyRules($rules, $adapter);
	$engine->applyEffects($effects, $adapter);

	$email_phids = $adapter->getEmailPHIDs();
	if (!$email_phids) {
	return;
	}

	$xscript = $engine->getTranscript();

	$commit_name = $adapter->getHeraldName();
	$revision = $adapter->loadDifferentialRevision();

	$name = null;
	if ($revision) {
	$name = ' '.$revision->getTitle();
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$reviewer_phid = $data->getCommitDetail('reviewerPHID');

	$phids = array_filter(array($author_phid, $reviewer_phid));

	$handles = array();
	if ($phids) {
	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
	}

	if ($author_phid) {
	$author_name = $handles[$author_phid]->getName();
	} else {
	$author_name = $data->getAuthorName();
	}

	if ($reviewer_phid) {
	$reviewer_name = $handles[$reviewer_phid]->getName();
	} else {
	$reviewer_name = null;
	}

	$who = implode(', ', array_filter(array($author_name, $reviewer_name)));

	$description = $data->getCommitMessage();

	$details = PhabricatorEnv::getProductionURI('/'.$commit_name);
	$differential = $revision
	? PhabricatorEnv::getProductionURI('/D'.$revision->getID())
	: 'No revision.';

	$files = $adapter->loadAffectedPaths();
	sort($files);
	$files = implode("\n ", $files);

	$xscript_id = $xscript->getID();

	$manage_uri = PhabricatorEnv::getProductionURI('/herald/view/commits/');
	$why_uri = PhabricatorEnv::getProductionURI(
	'/herald/transcript/'.$xscript_id.'/');

	$body = <<<EOBODY
	DESCRIPTION
	{$description}

	DETAILS
	{$details}

	DIFFERENTIAL REVISION
	{$differential}

	AFFECTED FILES
	{$files}

	MANAGE HERALD COMMIT RULES
	{$manage_uri}

	WHY DID I GET THIS EMAIL?
	{$why_uri}

	EOBODY;

	$subject = "[Herald/Commit] {$commit_name} ({$who}){$name}";

	$mailer = new PhabricatorMetaMTAMail();
	$mailer->setRelatedPHID($commit->getPHID());
	$mailer->addTos($email_phids);
	$mailer->setSubject($subject);
	$mailer->setBody($body);
	$mailer->setIsBulk(true);

	$mailer->addHeader('X-Herald-Rules', $xscript->getXHeraldRulesHeader());
	if ($author_phid) {
	$mailer->setFrom($author_phid);
	}

	$mailer->saveAndSend();
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 22:04 (6 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1129212
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions