No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/herald/controller/HeraldTranscriptController.php b/src/applications/herald/controller/HeraldTranscriptController.php
	index dc7ca676e3..60dd6dc6ed 100644
	--- a/src/applications/herald/controller/HeraldTranscriptController.php
	+++ b/src/applications/herald/controller/HeraldTranscriptController.php
	@@ -1,506 +1,600 @@
	<?php

	final class HeraldTranscriptController extends HeraldController {

	private $handles;
	private $adapter;

	private function getAdapter() {
	return $this->adapter;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $this->getViewer();

	$xscript = id(new HeraldTranscriptQuery())
	->setViewer($viewer)
	->withIDs(array($request->getURIData('id')))
	->executeOne();
	if (!$xscript) {
	return new Aphront404Response();
	}

	+ $object = $xscript->getObject();
	+
	require_celerity_resource('herald-test-css');
	$content = array();

	$object_xscript = $xscript->getObjectTranscript();
	if (!$object_xscript) {
	$notice = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE)
	->setTitle(pht('Old Transcript'))
	->appendChild(phutil_tag(
	'p',
	array(),
	pht('Details of this transcript have been garbage collected.')));
	$content[] = $notice;
	} else {
	$map = HeraldAdapter::getEnabledAdapterMap($viewer);
	$object_type = $object_xscript->getType();
	if (empty($map[$object_type])) {
	// TODO: We should filter these out in the Query, but we have to load
	// the objectTranscript right now, which is potentially enormous. We
	// should denormalize the object type, or move the data into a separate
	// table, and then filter this earlier (and thus raise a better error).
	// For now, just block access so we don't violate policies.
	throw new Exception(
	pht('This transcript has an invalid or inaccessible adapter.'));
	}

	$this->adapter = HeraldAdapter::getAdapterForContentType($object_type);

	$phids = $this->getTranscriptPHIDs($xscript);
	$phids = array_unique($phids);
	$phids = array_filter($phids);

	$handles = $this->loadViewerHandles($phids);
	$this->handles = $handles;

	if ($xscript->getDryRun()) {
	$notice = new PHUIInfoView();
	$notice->setSeverity(PHUIInfoView::SEVERITY_NOTICE);
	$notice->setTitle(pht('Dry Run'));
	$notice->appendChild(
	pht(
	'This was a dry run to test Herald rules, '.
	'no actions were executed.'));
	$content[] = $notice;
	}

	$warning_panel = $this->buildWarningPanel($xscript);
	$content[] = $warning_panel;

	$content[] = array(
	$this->buildActionTranscriptPanel($xscript),
	$this->buildObjectTranscriptPanel($xscript),
	+ $this->buildTransactionsTranscriptPanel(
	+ $object,
	+ $xscript),
	);
	}

	$crumbs = id($this->buildApplicationCrumbs())
	->addTextCrumb(
	pht('Transcripts'),
	$this->getApplicationURI('/transcript/'))
	->addTextCrumb($xscript->getID())
	->setBorder(true);

	$title = pht('Transcript: %s', $xscript->getID());

	$header = id(new PHUIHeaderView())
	->setHeader($title)
	->setHeaderIcon('fa-file');

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter($content);

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild(
	array(
	$view,
	));
	}

	protected function renderConditionTestValue($condition, $handles) {
	// TODO: This is all a hacky mess and should be driven through FieldValue
	// eventually.

	switch ($condition->getFieldName()) {
	case HeraldAnotherRuleField::FIELDCONST:
	$value = array($condition->getTestValue());
	break;
	default:
	$value = $condition->getTestValue();
	break;
	}

	if (!is_scalar($value) && $value !== null) {
	foreach ($value as $key => $phid) {
	$handle = idx($handles, $phid);
	if ($handle && $handle->isComplete()) {
	$value[$key] = $handle->getName();
	} else {
	// This happens for things like task priorities, statuses, and
	// custom fields.
	$value[$key] = $phid;
	}
	}
	sort($value);
	$value = implode(', ', $value);
	}

	return phutil_tag('span', array('class' => 'condition-test-value'), $value);
	}

	protected function getTranscriptPHIDs($xscript) {
	$phids = array();

	$object_xscript = $xscript->getObjectTranscript();
	if (!$object_xscript) {
	return array();
	}

	$phids[] = $object_xscript->getPHID();

	foreach ($xscript->getApplyTranscripts() as $apply_xscript) {
	// TODO: This is total hacks. Add another amazing layer of abstraction.
	$target = (array)$apply_xscript->getTarget();
	foreach ($target as $phid) {
	if ($phid) {
	$phids[] = $phid;
	}
	}
	}

	foreach ($xscript->getRuleTranscripts() as $rule_xscript) {
	$phids[] = $rule_xscript->getRuleOwner();
	}

	$condition_xscripts = $xscript->getConditionTranscripts();
	if ($condition_xscripts) {
	$condition_xscripts = call_user_func_array(
	'array_merge',
	$condition_xscripts);
	}
	foreach ($condition_xscripts as $condition_xscript) {
	switch ($condition_xscript->getFieldName()) {
	case HeraldAnotherRuleField::FIELDCONST:
	$phids[] = $condition_xscript->getTestValue();
	break;
	default:
	$value = $condition_xscript->getTestValue();
	// TODO: Also total hacks.
	if (is_array($value)) {
	foreach ($value as $phid) {
	if ($phid) {
	// TODO: Probably need to make sure this
	// "looks like" a PHID or decrease the level of hacks here;
	// this used to be an is_numeric() check in Facebook land.
	$phids[] = $phid;
	}
	}
	}
	break;
	}
	}

	return $phids;
	}

	private function buildWarningPanel(HeraldTranscript $xscript) {
	$request = $this->getRequest();
	$panel = null;
	if ($xscript->getObjectTranscript()) {
	$handles = $this->handles;
	$object_xscript = $xscript->getObjectTranscript();
	$handle = $handles[$object_xscript->getPHID()];
	if ($handle->getType() ==
	PhabricatorRepositoryCommitPHIDType::TYPECONST) {
	$commit = id(new DiffusionCommitQuery())
	->setViewer($request->getUser())
	->withPHIDs(array($handle->getPHID()))
	->executeOne();
	if ($commit) {
	$repository = $commit->getRepository();
	if ($repository->isImporting()) {
	$title = pht(
	'The %s repository is still importing.',
	$repository->getMonogram());
	$body = pht(
	'Herald rules will not trigger until import completes.');
	} else if (!$repository->isTracked()) {
	$title = pht(
	'The %s repository is not tracked.',
	$repository->getMonogram());
	$body = pht(
	'Herald rules will not trigger until tracking is enabled.');
	} else {
	return $panel;
	}
	$panel = id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setTitle($title)
	->appendChild($body);
	}
	}
	}
	return $panel;
	}

	private function buildActionTranscriptPanel(HeraldTranscript $xscript) {
	$action_xscript = mgroup($xscript->getApplyTranscripts(), 'getRuleID');

	$adapter = $this->getAdapter();

	$field_names = $adapter->getFieldNameMap();
	$condition_names = $adapter->getConditionNameMap();

	$handles = $this->handles;

	$action_map = $xscript->getApplyTranscripts();
	$action_map = mgroup($action_map, 'getRuleID');

	$rule_list = id(new PHUIObjectItemListView())
	->setNoDataString(pht('No Herald rules applied to this object.'))
	->setFlush(true);

	$rule_xscripts = $xscript->getRuleTranscripts();
	$rule_xscripts = msort($rule_xscripts, 'getRuleID');
	foreach ($rule_xscripts as $rule_xscript) {
	$rule_id = $rule_xscript->getRuleID();

	$rule_monogram = pht('H%d', $rule_id);
	$rule_uri = '/'.$rule_monogram;

	$rule_item = id(new PHUIObjectItemView())
	->setObjectName($rule_monogram)
	->setHeader($rule_xscript->getRuleName())
	->setHref($rule_uri);

	if (!$rule_xscript->getResult()) {
	$rule_item->setDisabled(true);
	}

	$rule_list->addItem($rule_item);

	// Build the field/condition transcript.

	$cond_xscripts = $xscript->getConditionTranscriptsForRule($rule_id);

	$cond_list = id(new PHUIStatusListView());
	$cond_list->addItem(
	id(new PHUIStatusItemView())
	->setTarget(phutil_tag('strong', array(), pht('Conditions'))));

	foreach ($cond_xscripts as $cond_xscript) {
	if ($cond_xscript->isForbidden()) {
	$icon = 'fa-ban';
	$color = 'indigo';
	$result = pht('Forbidden');
	} else if ($cond_xscript->getResult()) {
	$icon = 'fa-check';
	$color = 'green';
	$result = pht('Passed');
	} else {
	$icon = 'fa-times';
	$color = 'red';
	$result = pht('Failed');
	}

	if ($cond_xscript->getNote()) {
	$note_text = $cond_xscript->getNote();
	if ($cond_xscript->isForbidden()) {
	$note_text = HeraldStateReasons::getExplanation($note_text);
	}

	$note = phutil_tag(
	'div',
	array(
	'class' => 'herald-condition-note',
	),
	$note_text);
	} else {
	$note = null;
	}

	// TODO: This is not really translatable and should be driven through
	// HeraldField.
	$explanation = pht(
	'%s %s %s',
	idx($field_names, $cond_xscript->getFieldName(), pht('Unknown')),
	idx($condition_names, $cond_xscript->getCondition(), pht('Unknown')),
	$this->renderConditionTestValue($cond_xscript, $handles));

	$cond_item = id(new PHUIStatusItemView())
	->setIcon($icon, $color)
	->setTarget($result)
	->setNote(array($explanation, $note));

	$cond_list->addItem($cond_item);
	}

	if ($rule_xscript->isForbidden()) {
	$last_icon = 'fa-ban';
	$last_color = 'indigo';
	$last_result = pht('Forbidden');
	$last_note = pht('Object state prevented rule evaluation.');
	} else if ($rule_xscript->getResult()) {
	$last_icon = 'fa-check-circle';
	$last_color = 'green';
	$last_result = pht('Passed');
	$last_note = pht('Rule passed.');
	} else {
	$last_icon = 'fa-times-circle';
	$last_color = 'red';
	$last_result = pht('Failed');
	$last_note = pht('Rule failed.');
	}

	$cond_last = id(new PHUIStatusItemView())
	->setIcon($last_icon, $last_color)
	->setTarget(phutil_tag('strong', array(), $last_result))
	->setNote($last_note);
	$cond_list->addItem($cond_last);

	$cond_box = id(new PHUIBoxView())
	->appendChild($cond_list)
	->addMargin(PHUI::MARGIN_LARGE_LEFT);

	$rule_item->appendChild($cond_box);

	if (!$rule_xscript->getResult()) {
	// If the rule didn't pass, don't generate an action transcript since
	// actions didn't apply.
	continue;
	}

	$cond_box->addMargin(PHUI::MARGIN_MEDIUM_BOTTOM);

	$action_xscripts = idx($action_map, $rule_id, array());
	foreach ($action_xscripts as $action_xscript) {
	$action_key = $action_xscript->getAction();
	$action = $adapter->getActionImplementation($action_key);

	if ($action) {
	$name = $action->getHeraldActionName();
	$action->setViewer($this->getViewer());
	} else {
	$name = pht('Unknown Action ("%s")', $action_key);
	}

	$name = pht('Action: %s', $name);

	$action_list = id(new PHUIStatusListView());
	$action_list->addItem(
	id(new PHUIStatusItemView())
	->setTarget(phutil_tag('strong', array(), $name)));

	$action_box = id(new PHUIBoxView())
	->appendChild($action_list)
	->addMargin(PHUI::MARGIN_LARGE_LEFT);

	$rule_item->appendChild($action_box);

	$log = $action_xscript->getAppliedReason();

	// Handle older transcripts which used a static string to record
	// action results.

	if ($xscript->getDryRun()) {
	$action_list->addItem(
	id(new PHUIStatusItemView())
	->setIcon('fa-ban', 'grey')
	->setTarget(pht('Dry Run'))
	->setNote(
	pht(
	'This was a dry run, so no actions were taken.')));
	continue;
	} else if (!is_array($log)) {
	$action_list->addItem(
	id(new PHUIStatusItemView())
	->setIcon('fa-clock-o', 'grey')
	->setTarget(pht('Old Transcript'))
	->setNote(
	pht(
	'This is an old transcript which uses an obsolete log '.
	'format. Detailed action information is not available.')));
	continue;
	}

	foreach ($log as $entry) {
	$type = idx($entry, 'type');
	$data = idx($entry, 'data');

	if ($action) {
	$icon = $action->renderActionEffectIcon($type, $data);
	$color = $action->renderActionEffectColor($type, $data);
	$name = $action->renderActionEffectName($type, $data);
	$note = $action->renderEffectDescription($type, $data);
	} else {
	$icon = 'fa-question-circle';
	$color = 'indigo';
	$name = pht('Unknown Effect ("%s")', $type);
	$note = null;
	}

	$action_item = id(new PHUIStatusItemView())
	->setIcon($icon, $color)
	->setTarget($name)
	->setNote($note);

	$action_list->addItem($action_item);
	}
	}
	}

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Rule Transcript'))
	->appendChild($rule_list);

	return $box;
	}

	private function buildObjectTranscriptPanel(HeraldTranscript $xscript) {

	$adapter = $this->getAdapter();
	$field_names = $adapter->getFieldNameMap();

	$object_xscript = $xscript->getObjectTranscript();

	$data = array();
	if ($object_xscript) {
	$phid = $object_xscript->getPHID();
	$handles = $this->handles;

	$data += array(
	pht('Object Name') => $object_xscript->getName(),
	pht('Object Type') => $object_xscript->getType(),
	pht('Object PHID') => $phid,
	pht('Object Link') => $handles[$phid]->renderLink(),
	);
	}

	$data += $xscript->getMetadataMap();

	if ($object_xscript) {
	foreach ($object_xscript->getFields() as $field => $value) {
	$field = idx($field_names, $field, '['.$field.'?]');
	$data['Field: '.$field] = $value;
	}
	}

	$rows = array();
	foreach ($data as $name => $value) {
	if (!($value instanceof PhutilSafeHTML)) {
	if (!is_scalar($value) && !is_null($value)) {
	$value = implode("\n", $value);
	}

	if (strlen($value) > 256) {
	$value = phutil_tag(
	'textarea',
	array(
	'class' => 'herald-field-value-transcript',
	),
	$value);
	}
	}

	$rows[] = array($name, $value);
	}

	$property_list = new PHUIPropertyListView();
	$property_list->setStacked(true);
	foreach ($rows as $row) {
	$property_list->addProperty($row[0], $row[1]);
	}

	$box = new PHUIObjectBoxView();
	$box->setHeaderText(pht('Object Transcript'));
	$box->appendChild($property_list);

	return $box;
	}

	+ private function buildTransactionsTranscriptPanel(
	+ $object,
	+ HeraldTranscript $xscript) {
	+ $viewer = $this->getViewer();
	+
	+ $object_xscript = $xscript->getObjectTranscript();
	+
	+ $xaction_phids = $object_xscript->getAppliedTransactionPHIDs();
	+
	+ // If the value is "null", this is an older transcript or this adapter
	+ // does not use transactions. We render nothing.
	+ //
	+ // If the value is "array()", this is a modern transcript which uses
	+ // transactions, there just weren't any applied. Below, we'll render a
	+ // "No Transactions Applied" state.
	+ if ($xaction_phids === null) {
	+ return null;
	+ }
	+
	+ // If this object doesn't implement the right interface, we won't be
	+ // able to load the transactions. Just bail.
	+ if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
	+ return null;
	+ }
	+
	+ $query = PhabricatorApplicationTransactionQuery::newQueryForObject(
	+ $object);
	+
	+ if ($xaction_phids) {
	+ $xactions = $query
	+ ->setViewer($viewer)
	+ ->withPHIDs($xaction_phids)
	+ ->execute();
	+ $xactions = mpull($xactions, null, 'getPHID');
	+ } else {
	+ $xactions = array();
	+ }
	+
	+ $rows = array();
	+ foreach ($xaction_phids as $xaction_phid) {
	+ $xaction = idx($xactions, $xaction_phid);
	+
	+ $xaction_identifier = $xaction_phid;
	+ $xaction_date = null;
	+ $xaction_display = null;
	+ if ($xaction) {
	+ $xaction_identifier = $xaction->getID();
	+ $xaction_date = phabricator_datetime(
	+ $xaction->getDateCreated(),
	+ $viewer);
	+
	+ // Since we don't usually render transactions outside of the context
	+ // of objects, some of them might depend on missing object data. Out of
	+ // an abundance of caution, catch any rendering issues.
	+ try {
	+ $xaction_display = $xaction->getTitle();
	+ } catch (Exception $ex) {
	+ $xaction_display = $ex->getMessage();
	+ }
	+ }
	+
	+ $rows[] = array(
	+ $xaction_identifier,
	+ $xaction_display,
	+ $xaction_date,
	+ );
	+ }
	+
	+ $table_view = id(new AphrontTableView($rows))
	+ ->setHeaders(
	+ array(
	+ pht('ID'),
	+ pht('Transaction'),
	+ pht('Date'),
	+ ))
	+ ->setColumnClasses(
	+ array(
	+ null,
	+ 'wide',
	+ null,
	+ ));
	+
	+ $box_view = id(new PHUIObjectBoxView())
	+ ->setHeaderText(pht('Transactions'))
	+ ->setTable($table_view);
	+
	+ return $box_view;
	+ }
	+

	}
	diff --git a/src/applications/herald/engine/HeraldEngine.php b/src/applications/herald/engine/HeraldEngine.php
	index d853e3eb9a..2d96532882 100644
	--- a/src/applications/herald/engine/HeraldEngine.php
	+++ b/src/applications/herald/engine/HeraldEngine.php
	@@ -1,633 +1,640 @@
	<?php

	final class HeraldEngine extends Phobject {

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

	protected $fieldCache = array();
	protected $object;
	private $dryRun;

	private $forbiddenFields = array();
	private $forbiddenActions = array();
	private $skipEffects = array();

	public function setDryRun($dry_run) {
	$this->dryRun = $dry_run;
	return $this;
	}

	public function getDryRun() {
	return $this->dryRun;
	}

	public function getRule($phid) {
	return idx($this->rules, $phid);
	}

	public function loadRulesForAdapter(HeraldAdapter $adapter) {
	return id(new HeraldRuleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withDisabled(false)
	->withContentTypes(array($adapter->getAdapterContentType()))
	->needConditionsAndActions(true)
	->needAppliedToPHIDs(array($adapter->getPHID()))
	->needValidateAuthors(true)
	->execute();
	}

	public static function loadAndApplyRules(HeraldAdapter $adapter) {
	$engine = new HeraldEngine();

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

	return $engine->getTranscript();
	}

	public function applyRules(array $rules, HeraldAdapter $object) {
	assert_instances_of($rules, 'HeraldRule');
	$t_start = microtime(true);

	// Rules execute in a well-defined order: sort them into execution order.
	$rules = msort($rules, 'getRuleExecutionOrderSortKey');
	$rules = mpull($rules, null, 'getPHID');

	$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 $phid => $rule) {
	$this->stack = array();

	$is_first_only = $rule->isRepeatFirst();

	try {
	if (!$this->getDryRun() &&
	$is_first_only &&
	$rule->getRuleApplied($object->getPHID())) {
	// This is not a dry run, and this rule is only supposed to be
	// applied a single time, and it's already been applied...
	// That means automatic failure.
	$this->newRuleTranscript($rule)
	->setResult(false)
	->setReason(
	pht(
	'This rule is only supposed to be repeated a single time, '.
	'and it has already been applied.'));

	$rule_matches = false;
	} else {
	if ($this->isForbidden($rule, $object)) {
	$this->newRuleTranscript($rule)
	->setResult(HeraldRuleTranscript::RESULT_FORBIDDEN)
	->setReason(
	pht(
	'Object state is not compatible with rule.'));

	$rule_matches = false;
	} else {
	$rule_matches = $this->doesRuleMatch($rule, $object);
	}
	}
	} catch (HeraldRecursiveConditionsException $ex) {
	$names = array();
	foreach ($this->stack as $rule_phid => $ignored) {
	$names[] = '"'.$rules[$rule_phid]->getName().'"';
	}
	$names = implode(', ', $names);
	foreach ($this->stack as $rule_phid => $ignored) {
	$this->newRuleTranscript($rules[$rule_phid])
	->setResult(false)
	->setReason(
	pht(
	"Rules %s are recursively dependent upon one another! ".
	"Don't do this! You have formed an unresolvable cycle in the ".
	"dependency graph!",
	$names));
	}
	$rule_matches = false;
	}
	$this->results[$phid] = $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->getAdapterContentType());
	- $object_transcript->setFields($this->fieldCache);
	+ $xaction_phids = null;
	+ $xactions = $object->getAppliedTransactions();
	+ if ($xactions !== null) {
	+ $xaction_phids = mpull($xactions, 'getPHID');
	+ }
	+
	+ $object_transcript = id(new HeraldObjectTranscript())
	+ ->setPHID($object->getPHID())
	+ ->setName($object->getHeraldName())
	+ ->setType($object->getAdapterContentType())
	+ ->setFields($this->fieldCache)
	+ ->setAppliedTransactionPHIDs($xaction_phids);

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

	$t_end = microtime(true);

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

	return $effects;
	}

	public function applyEffects(
	array $effects,
	HeraldAdapter $adapter,
	array $rules) {
	assert_instances_of($effects, 'HeraldEffect');
	assert_instances_of($rules, 'HeraldRule');

	$this->transcript->setDryRun((int)$this->getDryRun());

	if ($this->getDryRun()) {
	$xscripts = array();
	foreach ($effects as $effect) {
	$xscripts[] = new HeraldApplyTranscript(
	$effect,
	false,
	pht('This was a dry run, so no actions were actually taken.'));
	}
	} else {
	$xscripts = $adapter->applyHeraldEffects($effects);
	}

	assert_instances_of($xscripts, 'HeraldApplyTranscript');
	foreach ($xscripts as $apply_xscript) {
	$this->transcript->addApplyTranscript($apply_xscript);
	}

	// For dry runs, don't mark the rule as having applied to the object.
	if ($this->getDryRun()) {
	return;
	}

	// Update the "applied" state table. How this table works depends on the
	// repetition policy for the rule.
	//
	// REPEAT_EVERY: We delete existing rows for the rule, then write nothing.
	// This policy doesn't use any state.
	//
	// REPEAT_FIRST: We keep existing rows, then write additional rows for
	// rules which fired. This policy accumulates state over the life of the
	// object.
	//
	// REPEAT_CHANGE: We delete existing rows, then write all the rows which
	// matched. This policy only uses the state from the previous run.

	$rules = mpull($rules, null, 'getID');
	$rule_ids = mpull($xscripts, 'getRuleID');

	$delete_ids = array();
	foreach ($rules as $rule_id => $rule) {
	if ($rule->isRepeatFirst()) {
	continue;
	}
	$delete_ids[] = $rule_id;
	}

	$applied_ids = array();
	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;
	}

	$rule = idx($rules, $rule_id);
	if (!$rule) {
	continue;
	}

	if ($rule->isRepeatFirst() \|\| $rule->isRepeatOnChange()) {
	$applied_ids[] = $rule_id;
	}
	}

	// Also include "only if this rule did not match the last time" rules
	// which matched but were skipped in the "applied" list.
	foreach ($this->skipEffects as $rule_id => $ignored) {
	$applied_ids[] = $rule_id;
	}

	if ($delete_ids \|\| $applied_ids) {
	$conn_w = id(new HeraldRule())->establishConnection('w');

	if ($delete_ids) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE phid = %s AND ruleID IN (%Ld)',
	HeraldRule::TABLE_RULE_APPLIED,
	$adapter->getPHID(),
	$delete_ids);
	}

	if ($applied_ids) {
	$sql = array();
	foreach ($applied_ids as $id) {
	$sql[] = qsprintf(
	$conn_w,
	'(%s, %d)',
	$adapter->getPHID(),
	$id);
	}
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (phid, ruleID) VALUES %LQ',
	HeraldRule::TABLE_RULE_APPLIED,
	$sql);
	}
	}
	}

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

	public function doesRuleMatch(
	HeraldRule $rule,
	HeraldAdapter $object) {

	$phid = $rule->getPHID();

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

	if (isset($this->stack[$phid])) {
	// 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_phid => $ignored) {
	$this->results[$rule_phid] = false;
	}
	throw new HeraldRecursiveConditionsException();
	}

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

	$all = $rule->getMustMatchAll();

	$conditions = $rule->getConditions();

	$result = null;

	$local_version = id(new HeraldRule())->getConfigVersion();
	if ($rule->getConfigVersion() > $local_version) {
	$reason = pht(
	'Rule could not be processed, it was created with a newer version '.
	'of Herald.');
	$result = false;
	} else if (!$conditions) {
	$reason = pht(
	'Rule failed automatically because it has no conditions.');
	$result = false;
	} else if (!$rule->hasValidAuthor()) {
	$reason = pht(
	'Rule failed automatically because its owner is invalid '.
	'or disabled.');
	$result = false;
	} else if (!$this->canAuthorViewObject($rule, $object)) {
	$reason = pht(
	'Rule failed automatically because it is a personal rule and its '.
	'owner can not see the object.');
	$result = false;
	} else if (!$this->canRuleApplyToObject($rule, $object)) {
	$reason = pht(
	'Rule failed automatically because it is an object rule which is '.
	'not relevant for this object.');
	$result = false;
	} else {
	foreach ($conditions as $condition) {
	try {
	$this->getConditionObjectValue($condition, $object);
	} catch (Exception $ex) {
	$reason = pht(
	'Field "%s" does not exist!',
	$condition->getFieldName());
	$result = false;
	break;
	}

	$match = $this->doesConditionMatch($rule, $condition, $object);

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

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

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

	// If this rule matched, and is set to run "if it did not match the last
	// time", and we matched the last time, we're going to return a match in
	// the transcript but set a flag so we don't actually apply any effects.

	// We need the rule to match so that storage gets updated properly. If we
	// just pretend the rule didn't match it won't cause any effects (which
	// is correct), but it also won't set the "it matched" flag in storage,
	// so the next run after this one would incorrectly trigger again.

	$is_dry_run = $this->getDryRun();
	if ($result && !$is_dry_run) {
	$is_on_change = $rule->isRepeatOnChange();
	if ($is_on_change) {
	$did_apply = $rule->getRuleApplied($object->getPHID());
	if ($did_apply) {
	$reason = pht(
	'This rule matched, but did not take any actions because it '.
	'is configured to act only if it did not match the last time.');

	$this->skipEffects[$rule->getID()] = true;
	}
	}
	}

	$this->newRuleTranscript($rule)
	->setResult($result)
	->setReason($reason);

	return $result;
	}

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

	$object_value = $this->getConditionObjectValue($condition, $object);
	$transcript = $this->newConditionTranscript($rule, $condition);

	try {
	$result = $object->doesConditionMatch(
	$this,
	$rule,
	$condition,
	$object_value);
	} catch (HeraldInvalidConditionException $ex) {
	$result = false;
	$transcript->setNote($ex->getMessage());
	}

	$transcript->setResult($result);

	return $result;
	}

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

	$field = $condition->getFieldName();

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

	public function getObjectFieldValue($field) {
	if (!array_key_exists($field, $this->fieldCache)) {
	$this->fieldCache[$field] = $this->object->getHeraldField($field);
	}

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

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

	$rule_id = $rule->getID();
	if (isset($this->skipEffects[$rule_id])) {
	return array();
	}

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

	$name = $rule->getName();
	$id = $rule->getID();
	$effect->setReason(
	pht(
	'Conditions were met for %s',
	"H{$id} {$name}"));

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

	private function canAuthorViewObject(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	// Authorship is irrelevant for global rules and object rules.
	if ($rule->isGlobalRule() \|\| $rule->isObjectRule()) {
	return true;
	}

	// The author must be able to create rules for the adapter's content type.
	// In particular, this means that the application must be installed and
	// accessible to the user. For example, if a user writes a Differential
	// rule and then loses access to Differential, this disables the rule.
	$enabled = HeraldAdapter::getEnabledAdapterMap($rule->getAuthor());
	if (empty($enabled[$adapter->getAdapterContentType()])) {
	return false;
	}

	// Finally, the author must be able to see the object itself. You can't
	// write a personal rule that CC's you on revisions you wouldn't otherwise
	// be able to see, for example.
	$object = $adapter->getObject();
	return PhabricatorPolicyFilter::hasCapability(
	$rule->getAuthor(),
	$object,
	PhabricatorPolicyCapability::CAN_VIEW);
	}

	private function canRuleApplyToObject(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	// Rules which are not object rules can apply to anything.
	if (!$rule->isObjectRule()) {
	return true;
	}

	$trigger_phid = $rule->getTriggerObjectPHID();
	$object_phids = $adapter->getTriggerObjectPHIDs();

	if ($object_phids) {
	if (in_array($trigger_phid, $object_phids)) {
	return true;
	}
	}

	return false;
	}

	private function newRuleTranscript(HeraldRule $rule) {
	$xscript = id(new HeraldRuleTranscript())
	->setRuleID($rule->getID())
	->setRuleName($rule->getName())
	->setRuleOwner($rule->getAuthorPHID());

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

	return $xscript;
	}

	private function newConditionTranscript(
	HeraldRule $rule,
	HeraldCondition $condition) {

	$xscript = id(new HeraldConditionTranscript())
	->setRuleID($rule->getID())
	->setConditionID($condition->getID())
	->setFieldName($condition->getFieldName())
	->setCondition($condition->getFieldCondition())
	->setTestValue($condition->getValue());

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

	return $xscript;
	}

	private function newApplyTranscript(
	HeraldAdapter $adapter,
	HeraldRule $rule,
	HeraldActionRecord $action) {

	$effect = id(new HeraldEffect())
	->setObjectPHID($adapter->getPHID())
	->setAction($action->getAction())
	->setTarget($action->getTarget())
	->setRule($rule);

	$xscript = new HeraldApplyTranscript($effect, false);

	$this->transcript->addApplyTranscript($xscript);

	return $xscript;
	}

	private function isForbidden(
	HeraldRule $rule,
	HeraldAdapter $adapter) {

	$forbidden = $adapter->getForbiddenActions();
	if (!$forbidden) {
	return false;
	}

	$forbidden = array_fuse($forbidden);

	$is_forbidden = false;

	foreach ($rule->getConditions() as $condition) {
	$field_key = $condition->getFieldName();

	if (!isset($this->forbiddenFields[$field_key])) {
	$reason = null;

	try {
	$states = $adapter->getRequiredFieldStates($field_key);
	} catch (Exception $ex) {
	$states = array();
	}

	foreach ($states as $state) {
	if (!isset($forbidden[$state])) {
	continue;
	}
	$reason = $adapter->getForbiddenReason($state);
	break;
	}

	$this->forbiddenFields[$field_key] = $reason;
	}

	$forbidden_reason = $this->forbiddenFields[$field_key];
	if ($forbidden_reason !== null) {
	$this->newConditionTranscript($rule, $condition)
	->setResult(HeraldConditionTranscript::RESULT_FORBIDDEN)
	->setNote($forbidden_reason);

	$is_forbidden = true;
	}
	}

	foreach ($rule->getActions() as $action_record) {
	$action_key = $action_record->getAction();

	if (!isset($this->forbiddenActions[$action_key])) {
	$reason = null;

	try {
	$states = $adapter->getRequiredActionStates($action_key);
	} catch (Exception $ex) {
	$states = array();
	}

	foreach ($states as $state) {
	if (!isset($forbidden[$state])) {
	continue;
	}
	$reason = $adapter->getForbiddenReason($state);
	break;
	}

	$this->forbiddenActions[$action_key] = $reason;
	}

	$forbidden_reason = $this->forbiddenActions[$action_key];
	if ($forbidden_reason !== null) {
	$this->newApplyTranscript($adapter, $rule, $action_record)
	->setAppliedReason(
	array(
	array(
	'type' => HeraldAction::DO_STANDARD_FORBIDDEN,
	'data' => $forbidden_reason,
	),
	));

	$is_forbidden = true;
	}
	}

	return $is_forbidden;
	}

	}
	diff --git a/src/applications/herald/query/HeraldTranscriptQuery.php b/src/applications/herald/query/HeraldTranscriptQuery.php
	index 71789e07c5..00a9dffeaf 100644
	--- a/src/applications/herald/query/HeraldTranscriptQuery.php
	+++ b/src/applications/herald/query/HeraldTranscriptQuery.php
	@@ -1,126 +1,136 @@
	<?php

	final class HeraldTranscriptQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $objectPHIDs;
	private $needPartialRecords;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withObjectPHIDs(array $phids) {
	$this->objectPHIDs = $phids;
	return $this;
	}

	public function needPartialRecords($need_partial) {
	$this->needPartialRecords = $need_partial;
	return $this;
	}

	protected function loadPage() {
	$transcript = new HeraldTranscript();
	$conn = $transcript->establishConnection('r');

	// NOTE: Transcripts include a potentially enormous amount of serialized
	// data, so we're loading only some of the fields here if the caller asked
	// for partial records.

	if ($this->needPartialRecords) {
	$fields = array(
	'id',
	'phid',
	'objectPHID',
	'time',
	'duration',
	'dryRun',
	'host',
	);
	$fields = qsprintf($conn, '%LC', $fields);
	} else {
	$fields = qsprintf($conn, '*');
	}

	$rows = queryfx_all(
	$conn,
	'SELECT %Q FROM %T t %Q %Q %Q',
	$fields,
	$transcript->getTableName(),
	$this->buildWhereClause($conn),
	$this->buildOrderClause($conn),
	$this->buildLimitClause($conn));

	$transcripts = $transcript->loadAllFromArray($rows);

	if ($this->needPartialRecords) {
	// Make sure nothing tries to write these; they aren't complete.
	foreach ($transcripts as $transcript) {
	$transcript->makeEphemeral();
	}
	}

	return $transcripts;
	}

	protected function willFilterPage(array $transcripts) {
	$phids = mpull($transcripts, 'getObjectPHID');

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($phids)
	->execute();

	foreach ($transcripts as $key => $transcript) {
	- if (empty($objects[$transcript->getObjectPHID()])) {
	+ $object_phid = $transcript->getObjectPHID();
	+
	+ if (!$object_phid) {
	+ $transcript->attachObject(null);
	+ continue;
	+ }
	+
	+ $object = idx($objects, $object_phid);
	+ if (!$object) {
	$this->didRejectResult($transcript);
	unset($transcripts[$key]);
	}
	+
	+ $transcript->attachObject($object);
	}

	return $transcripts;
	}

	protected function buildWhereClause(AphrontDatabaseConnection $conn) {
	$where = array();

	if ($this->ids) {
	$where[] = qsprintf(
	$conn,
	'id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn,
	'phid IN (%Ls)',
	$this->phids);
	}

	if ($this->objectPHIDs) {
	$where[] = qsprintf(
	$conn,
	'objectPHID in (%Ls)',
	$this->objectPHIDs);
	}

	$where[] = $this->buildPagingClause($conn);

	return $this->formatWhereClause($conn, $where);
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorHeraldApplication';
	}

	}
	diff --git a/src/applications/herald/storage/transcript/HeraldObjectTranscript.php b/src/applications/herald/storage/transcript/HeraldObjectTranscript.php
	index e0b85162af..9d331b271e 100644
	--- a/src/applications/herald/storage/transcript/HeraldObjectTranscript.php
	+++ b/src/applications/herald/storage/transcript/HeraldObjectTranscript.php
	@@ -1,75 +1,85 @@
	<?php

	final class HeraldObjectTranscript extends Phobject {

	protected $phid;
	protected $type;
	protected $name;
	protected $fields;
	+ protected $appliedTransactionPHIDs;

	public function setPHID($phid) {
	$this->phid = $phid;
	return $this;
	}

	public function getPHID() {
	return $this->phid;
	}

	public function setType($type) {
	$this->type = $type;
	return $this;
	}

	public function getType() {
	return $this->type;
	}

	public function setName($name) {
	$this->name = $name;
	return $this;
	}

	public function getName() {
	return $this->name;
	}

	public function setFields(array $fields) {
	foreach ($fields as $key => $value) {
	$fields[$key] = self::truncateValue($value, 4096);
	}

	$this->fields = $fields;
	return $this;
	}

	public function getFields() {
	return $this->fields;
	}

	+ public function setAppliedTransactionPHIDs($phids) {
	+ $this->appliedTransactionPHIDs = $phids;
	+ return $this;
	+ }
	+
	+ public function getAppliedTransactionPHIDs() {
	+ return $this->appliedTransactionPHIDs;
	+ }
	+
	private static function truncateValue($value, $length) {
	if (is_string($value)) {
	if (strlen($value) <= $length) {
	return $value;
	} else {
	// NOTE: PhutilUTF8StringTruncator has huge runtime for giant strings.
	return phutil_utf8ize(substr($value, 0, $length)."\n<...>");
	}
	} else if (is_array($value)) {
	foreach ($value as $key => $v) {
	if ($length <= 0) {
	$value['<...>'] = '<...>';
	unset($value[$key]);
	} else {
	$v = self::truncateValue($v, $length);
	$length -= strlen($v);
	$value[$key] = $v;
	}
	}
	return $value;
	} else {
	return $value;
	}
	}

	}
	diff --git a/src/applications/herald/storage/transcript/HeraldTranscript.php b/src/applications/herald/storage/transcript/HeraldTranscript.php
	index 474eb10b53..9539d4653d 100644
	--- a/src/applications/herald/storage/transcript/HeraldTranscript.php
	+++ b/src/applications/herald/storage/transcript/HeraldTranscript.php
	@@ -1,235 +1,246 @@
	<?php

	final class HeraldTranscript extends HeraldDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorDestructibleInterface {

	protected $objectTranscript;
	protected $ruleTranscripts = array();
	protected $conditionTranscripts = array();
	protected $applyTranscripts = array();

	protected $time;
	protected $host;
	protected $duration;

	protected $objectPHID;
	protected $dryRun;
	protected $garbageCollected = 0;

	+ private $object = self::ATTACHABLE;
	+
	const TABLE_SAVED_HEADER = 'herald_savedheader';

	public function getXHeraldRulesHeader() {
	$ids = array();
	foreach ($this->applyTranscripts as $xscript) {
	if ($xscript->getApplied()) {
	if ($xscript->getRuleID()) {
	$ids[] = $xscript->getRuleID();
	}
	}
	}
	if (!$ids) {
	return 'none';
	}

	// A rule may have multiple effects, which will cause it to be listed
	// multiple times.
	$ids = array_unique($ids);

	foreach ($ids as $k => $id) {
	$ids[$k] = '<'.$id.'>';
	}

	return implode(', ', $ids);
	}

	public static function saveXHeraldRulesHeader($phid, $header) {

	// Combine any existing header with the new header, listing all rules
	// which have ever triggered for this object.
	$header = self::combineXHeraldRulesHeaders(
	self::loadXHeraldRulesHeader($phid),
	$header);

	queryfx(
	id(new HeraldTranscript())->establishConnection('w'),
	'INSERT INTO %T (phid, header) VALUES (%s, %s)
	ON DUPLICATE KEY UPDATE header = VALUES(header)',
	self::TABLE_SAVED_HEADER,
	$phid,
	$header);

	return $header;
	}

	private static function combineXHeraldRulesHeaders($u, $v) {
	$u = preg_split('/[, ]+/', $u);
	$v = preg_split('/[, ]+/', $v);

	$combined = array_unique(array_filter(array_merge($u, $v)));
	return implode(', ', $combined);
	}

	public static function loadXHeraldRulesHeader($phid) {
	$header = queryfx_one(
	id(new HeraldTranscript())->establishConnection('r'),
	'SELECT * FROM %T WHERE phid = %s',
	self::TABLE_SAVED_HEADER,
	$phid);
	if ($header) {
	return idx($header, 'header');
	}
	return null;
	}


	protected function getConfiguration() {
	// Ugh. Too much of a mess to deal with.
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_SERIALIZATION => array(
	'objectTranscript' => self::SERIALIZATION_PHP,
	'ruleTranscripts' => self::SERIALIZATION_PHP,
	'conditionTranscripts' => self::SERIALIZATION_PHP,
	'applyTranscripts' => self::SERIALIZATION_PHP,
	),
	self::CONFIG_BINARY => array(
	'objectTranscript' => true,
	'ruleTranscripts' => true,
	'conditionTranscripts' => true,
	'applyTranscripts' => true,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'time' => 'epoch',
	'host' => 'text255',
	'duration' => 'double',
	'dryRun' => 'bool',
	'garbageCollected' => 'bool',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'objectPHID' => array(
	'columns' => array('objectPHID'),
	),
	'garbageCollected' => array(
	'columns' => array('garbageCollected', 'time'),
	),
	),
	) + parent::getConfiguration();
	}

	public function __construct() {
	$this->time = time();
	$this->host = php_uname('n');
	}

	public function addApplyTranscript(HeraldApplyTranscript $transcript) {
	$this->applyTranscripts[] = $transcript;
	return $this;
	}

	public function getApplyTranscripts() {
	return nonempty($this->applyTranscripts, array());
	}

	public function setDuration($duration) {
	$this->duration = $duration;
	return $this;
	}

	public function setObjectTranscript(HeraldObjectTranscript $transcript) {
	$this->objectTranscript = $transcript;
	return $this;
	}

	public function getObjectTranscript() {
	return $this->objectTranscript;
	}

	public function addRuleTranscript(HeraldRuleTranscript $transcript) {
	$this->ruleTranscripts[$transcript->getRuleID()] = $transcript;
	return $this;
	}

	public function discardDetails() {
	$this->applyTranscripts = null;
	$this->ruleTranscripts = null;
	$this->objectTranscript = null;
	$this->conditionTranscripts = null;
	}

	public function getRuleTranscripts() {
	return nonempty($this->ruleTranscripts, array());
	}

	public function addConditionTranscript(
	HeraldConditionTranscript $transcript) {
	$rule_id = $transcript->getRuleID();
	$cond_id = $transcript->getConditionID();

	$this->conditionTranscripts[$rule_id][$cond_id] = $transcript;
	return $this;
	}

	public function getConditionTranscriptsForRule($rule_id) {
	return idx($this->conditionTranscripts, $rule_id, array());
	}

	public function getMetadataMap() {
	return array(
	pht('Run At Epoch') => date('F jS, g:i:s A', $this->time),
	pht('Run On Host') => $this->host,
	pht('Run Duration') => (int)(1000 * $this->duration).' ms',
	);
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	HeraldTranscriptPHIDType::TYPECONST);
	}

	+ public function attachObject($object = null) {
	+ $this->object = $object;
	+ return $this;
	+ }
	+
	+ public function getObject() {
	+ return $this->assertAttached($this->object);
	+ }
	+
	/* -( PhabricatorPolicyInterface )----------------------------------------- */

	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_USER;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht(
	'To view a transcript, you must be able to view the object the '.
	'transcript is about.');
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 2:40 PM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71957
Default Alt Text: (50 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions