No OneTemporary
Actions

Size

27 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/query/DifferentialDiffQuery.php b/src/applications/differential/query/DifferentialDiffQuery.php
	index 1616d58ac8..23c016446c 100644
	--- a/src/applications/differential/query/DifferentialDiffQuery.php
	+++ b/src/applications/differential/query/DifferentialDiffQuery.php
	@@ -1,123 +1,139 @@
	<?php

	final class DifferentialDiffQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $revisionIDs;
	+
	private $needChangesets = false;
	+ private $needProperties;

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

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

	public function withRevisionIDs(array $revision_ids) {
	$this->revisionIDs = $revision_ids;
	return $this;
	}

	public function needChangesets($bool) {
	$this->needChangesets = $bool;
	return $this;
	}

	+ public function needProperties($need_properties) {
	+ $this->needProperties = $need_properties;
	+ return $this;
	+ }
	+
	+ public function newResultObject() {
	+ return new DifferentialDiff();
	+ }
	+
	protected function loadPage() {
	- $table = new DifferentialDiff();
	- $conn_r = $table->establishConnection('r');
	-
	- $data = queryfx_all(
	- $conn_r,
	- 'SELECT * FROM %T %Q %Q %Q',
	- $table->getTableName(),
	- $this->buildWhereClause($conn_r),
	- $this->buildOrderClause($conn_r),
	- $this->buildLimitClause($conn_r));
	-
	- return $table->loadAllFromArray($data);
	+ return $this->loadStandardPage($this->newResultObject());
	}

	protected function willFilterPage(array $diffs) {
	$revision_ids = array_filter(mpull($diffs, 'getRevisionID'));

	$revisions = array();
	if ($revision_ids) {
	$revisions = id(new DifferentialRevisionQuery())
	->setViewer($this->getViewer())
	->withIDs($revision_ids)
	->execute();
	}

	foreach ($diffs as $key => $diff) {
	if (!$diff->getRevisionID()) {
	continue;
	}

	$revision = idx($revisions, $diff->getRevisionID());
	if ($revision) {
	$diff->attachRevision($revision);
	continue;
	}

	unset($diffs[$key]);
	}


	if ($diffs && $this->needChangesets) {
	$diffs = $this->loadChangesets($diffs);
	}

	return $diffs;
	}

	+ protected function didFilterPage(array $diffs) {
	+ if ($this->needProperties) {
	+ $properties = id(new DifferentialDiffProperty())->loadAllWhere(
	+ 'diffID IN (%Ld)',
	+ mpull($diffs, 'getID'));
	+
	+ $properties = mgroup($properties, 'getDiffID');
	+ foreach ($diffs as $diff) {
	+ $map = idx($properties, $diff->getID(), array());
	+ $map = mpull($map, 'getData', 'getName');
	+ $diff->attachDiffProperties($map);
	+ }
	+ }
	+
	+ return $diffs;
	+ }
	+
	private function loadChangesets(array $diffs) {
	id(new DifferentialChangesetQuery())
	->setViewer($this->getViewer())
	->setParentQuery($this)
	->withDiffs($diffs)
	->needAttachToDiffs(true)
	->needHunks(true)
	->execute();

	return $diffs;
	}

	- protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	- $where = array();
	+ protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	+ $where = parent::buildWhereClauseParts($conn);

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

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

	if ($this->revisionIDs) {
	$where[] = qsprintf(
	- $conn_r,
	+ $conn,
	'revisionID IN (%Ld)',
	$this->revisionIDs);
	}

	- $where[] = $this->buildPagingClause($conn_r);
	- return $this->formatWhereClause($where);
	+ return $where;
	}

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

	}
	diff --git a/src/applications/drydock/operation/DrydockLandRepositoryOperation.php b/src/applications/drydock/operation/DrydockLandRepositoryOperation.php
	index 77de219115..4e306772a3 100644
	--- a/src/applications/drydock/operation/DrydockLandRepositoryOperation.php
	+++ b/src/applications/drydock/operation/DrydockLandRepositoryOperation.php
	@@ -1,339 +1,443 @@
	<?php

	final class DrydockLandRepositoryOperation
	extends DrydockRepositoryOperationType {

	const OPCONST = 'land';

	const PHASE_PUSH = 'op.land.push';
	const PHASE_COMMIT = 'op.land.commit';

	public function getOperationDescription(
	DrydockRepositoryOperation $operation,
	PhabricatorUser $viewer) {
	return pht('Land Revision');
	}

	public function getOperationCurrentStatus(
	DrydockRepositoryOperation $operation,
	PhabricatorUser $viewer) {

	$target = $operation->getRepositoryTarget();
	$repository = $operation->getRepository();
	switch ($operation->getOperationState()) {
	case DrydockRepositoryOperation::STATE_WAIT:
	return pht(
	'Waiting to land revision into %s on %s...',
	$repository->getMonogram(),
	$target);
	case DrydockRepositoryOperation::STATE_WORK:
	return pht(
	'Landing revision into %s on %s...',
	$repository->getMonogram(),
	$target);
	case DrydockRepositoryOperation::STATE_DONE:
	return pht(
	'Revision landed into %s.',
	$repository->getMonogram());
	}
	}

	public function getWorkingCopyMerges(DrydockRepositoryOperation $operation) {
	$repository = $operation->getRepository();
	$merges = array();

	$object = $operation->getObject();
	if ($object instanceof DifferentialRevision) {
	$diff = $this->loadDiff($operation);
	$merges[] = array(
	'src.uri' => $repository->getStagingURI(),
	'src.ref' => $diff->getStagingRef(),
	);
	} else {
	throw new Exception(
	pht(
	'Invalid or unknown object ("%s") for land operation, expected '.
	'Differential Revision.',
	$operation->getObjectPHID()));
	}

	return $merges;
	}

	public function applyOperation(
	DrydockRepositoryOperation $operation,
	DrydockInterface $interface) {
	$viewer = $this->getViewer();
	$repository = $operation->getRepository();

	$cmd = array();
	$arg = array();

	$object = $operation->getObject();
	if ($object instanceof DifferentialRevision) {
	$revision = $object;

	$diff = $this->loadDiff($operation);

	$dict = $diff->getDiffAuthorshipDict();
	$author_name = idx($dict, 'authorName');
	$author_email = idx($dict, 'authorEmail');

	$api_method = 'differential.getcommitmessage';
	$api_params = array(
	'revision_id' => $revision->getID(),
	);

	$commit_message = id(new ConduitCall($api_method, $api_params))
	->setUser($viewer)
	->execute();
	} else {
	throw new Exception(
	pht(
	'Invalid or unknown object ("%s") for land operation, expected '.
	'Differential Revision.',
	$operation->getObjectPHID()));
	}

	$target = $operation->getRepositoryTarget();
	list($type, $name) = explode(':', $target, 2);
	switch ($type) {
	case 'branch':
	$push_dst = 'refs/heads/'.$name;
	break;
	default:
	throw new Exception(
	pht(
	'Unknown repository operation target type "%s" (in target "%s").',
	$type,
	$target));
	}

	$committer_info = $this->getCommitterInfo($operation);

	// NOTE: We're doing this commit with "-F -" so we don't run into trouble
	// with enormous commit messages which might otherwise exceed the maximum
	// size of a command.

	$future = $interface->getExecFuture(
	'git -c user.name=%s -c user.email=%s commit --author %s -F - --',
	$committer_info['name'],
	$committer_info['email'],
	"{$author_name} <{$author_email}>");

	$future->write($commit_message);

	try {
	$future->resolvex();
	} catch (CommandException $ex) {
	$display_command = csprintf('git commit');

	// TODO: One reason this can fail is if the changes have already been
	// merged. We could try to detect that.

	$error = DrydockCommandError::newFromCommandException($ex)
	->setPhase(self::PHASE_COMMIT)
	->setDisplayCommand($display_command);

	$operation->setCommandError($error->toDictionary());

	throw $ex;
	}

	try {
	$interface->execx(
	'git push origin -- %s:%s',
	'HEAD',
	$push_dst);
	} catch (CommandException $ex) {
	$display_command = csprintf(
	'git push origin %R:%R',
	'HEAD',
	$push_dst);

	$error = DrydockCommandError::newFromCommandException($ex)
	->setPhase(self::PHASE_PUSH)
	->setDisplayCommand($display_command);

	$operation->setCommandError($error->toDictionary());

	throw $ex;
	}
	}

	private function getCommitterInfo(DrydockRepositoryOperation $operation) {
	$viewer = $this->getViewer();

	$committer_name = null;

	$author_phid = $operation->getAuthorPHID();
	$object = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withPHIDs(array($author_phid))
	->executeOne();

	if ($object) {
	if ($object instanceof PhabricatorUser) {
	$committer_name = $object->getUsername();
	}
	}

	if (!strlen($committer_name)) {
	$committer_name = pht('autocommitter');
	}

	// TODO: Probably let users choose a VCS email address in settings. For
	// now just make something up so we don't leak anyone's stuff.

	return array(
	'name' => $committer_name,
	'email' => 'autocommitter@example.com',
	);
	}

	private function loadDiff(DrydockRepositoryOperation $operation) {
	$viewer = $this->getViewer();
	$revision = $operation->getObject();

	$diff_phid = $operation->getProperty('differential.diffPHID');

	$diff = id(new DifferentialDiffQuery())
	->setViewer($viewer)
	->withPHIDs(array($diff_phid))
	->executeOne();
	if (!$diff) {
	throw new Exception(
	pht(
	'Unable to load diff "%s".',
	$diff_phid));
	}

	$diff_revid = $diff->getRevisionID();
	$revision_id = $revision->getID();
	if ($diff_revid != $revision_id) {
	throw new Exception(
	pht(
	'Diff ("%s") has wrong revision ID ("%s", expected "%s").',
	$diff_phid,
	$diff_revid,
	$revision_id));
	}

	return $diff;
	}

	public function getBarrierToLanding(
	PhabricatorUser $viewer,
	DifferentialRevision $revision) {

	$repository = $revision->getRepository();
	if (!$repository) {
	return array(
	'title' => pht('No Repository'),
	'body' => pht(
	'This revision is not associated with a known repository. Only '.
	'revisions associated with a tracked repository can be landed '.
	'automatically.'),
	);
	}

	if (!$repository->canPerformAutomation()) {
	return array(
	'title' => pht('No Repository Automation'),
	'body' => pht(
	'The repository this revision is associated with ("%s") is not '.
	'configured to support automation. Configure automation for the '.
	'repository to enable revisions to be landed automatically.',
	$repository->getMonogram()),
	);
	}

	+ // Check if this diff was pushed to a staging area.
	+ $diff = id(new DifferentialDiffQuery())
	+ ->setViewer($viewer)
	+ ->withIDs(array($revision->getActiveDiff()->getID()))
	+ ->needProperties(true)
	+ ->executeOne();
	+
	+ // Older diffs won't have this property. They may still have been pushed.
	+ // At least for now, assume staging changes are present if the property
	+ // is missing. This should smooth the transition to the more formal
	+ // approach.
	+ $has_staging = $diff->hasDiffProperty('arc.staging');
	+ if ($has_staging) {
	+ $staging = $diff->getProperty('arc.staging');
	+ if (!is_array($staging)) {
	+ $staging = array();
	+ }
	+ $status = idx($staging, 'status');
	+ if ($status != ArcanistDiffWorkflow::STAGING_PUSHED) {
	+ return $this->getBarrierToLandingFromStagingStatus($status);
	+ }
	+ }
	+
	// TODO: At some point we should allow installs to give "land reviewed
	// code" permission to more users than "push any commit", because it is
	// a much less powerful operation. For now, just require push so this
	// doesn't do anything users can't do on their own.
	$can_push = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$repository,
	DiffusionPushCapability::CAPABILITY);
	if (!$can_push) {
	return array(
	'title' => pht('Unable to Push'),
	'body' => pht(
	'You do not have permission to push to the repository this '.
	'revision is associated with ("%s"), so you can not land it.',
	$repository->getMonogram()),
	);
	}

	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	if ($revision->getStatus() != $status_accepted) {
	switch ($revision->getStatus()) {
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return array(
	'title' => pht('Revision Closed'),
	'body' => pht(
	'This revision has already been closed. Only open, accepted '.
	'revisions may land.'),
	);
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	return array(
	'title' => pht('Revision Abandoned'),
	'body' => pht(
	'This revision has been abandoned. Only accepted revisions '.
	'may land.'),
	);
	default:
	return array(
	'title' => pht('Revision Not Accepted'),
	'body' => pht(
	'This revision is still under review. Only revisions which '.
	'have been accepted may land.'),
	);
	}
	}

	// Check for other operations. Eventually this should probably be more
	// general (e.g., it's OK to land to multiple different branches
	// simultaneously) but just put this in as a sanity check for now.
	$other_operations = id(new DrydockRepositoryOperationQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($revision->getPHID()))
	->withOperationTypes(
	array(
	$this->getOperationConstant(),
	))
	->withOperationStates(
	array(
	DrydockRepositoryOperation::STATE_WAIT,
	DrydockRepositoryOperation::STATE_WORK,
	DrydockRepositoryOperation::STATE_DONE,
	))
	->execute();

	if ($other_operations) {
	$any_done = false;
	foreach ($other_operations as $operation) {
	if ($operation->isDone()) {
	$any_done = true;
	break;
	}
	}

	if ($any_done) {
	return array(
	'title' => pht('Already Complete'),
	'body' => pht('This revision has already landed.'),
	);
	} else {
	return array(
	'title' => pht('Already In Flight'),
	'body' => pht('This revision is already landing.'),
	);
	}
	}

	return null;
	}

	+ private function getBarrierToLandingFromStagingStatus($status) {
	+ switch ($status) {
	+ case ArcanistDiffWorkflow::STAGING_USER_SKIP:
	+ return array(
	+ 'title' => pht('Staging Area Skipped'),
	+ 'body' => pht(
	+ 'The diff author used the %s flag to skip pushing this change to '.
	+ 'staging. Changes must be pushed to staging before they can be '.
	+ 'landed from the web.',
	+ phutil_tag('tt', array(), '--skip-staging')),
	+ );
	+ case ArcanistDiffWorkflow::STAGING_DIFF_RAW:
	+ return array(
	+ 'title' => pht('Raw Diff Source'),
	+ 'body' => pht(
	+ 'The diff was generated from a raw input source, so the change '.
	+ 'could not be pushed to staging. Changes must be pushed to '.
	+ 'staging before they can be landed from the web.'),
	+ );
	+ case ArcanistDiffWorkflow::STAGING_REPOSITORY_UNKNOWN:
	+ return array(
	+ 'title' => pht('Unknown Repository'),
	+ 'body' => pht(
	+ 'When the diff was generated, the client was not able to '.
	+ 'determine which repository it belonged to, so the change '.
	+ 'was not pushed to staging. Changes must be pushed to staging '.
	+ 'before they can be landed from the web.'),
	+ );
	+ case ArcanistDiffWorkflow::STAGING_REPOSITORY_UNAVAILABLE:
	+ return array(
	+ 'title' => pht('Staging Unavailable'),
	+ 'body' => pht(
	+ 'When this diff was generated, the server was running an older '.
	+ 'version of Phabricator which did not support staging areas, so '.
	+ 'the change was not pushed to staging. Changes must be pushed '.
	+ 'to staging before they can be landed from the web.'),
	+ );
	+ case ArcanistDiffWorkflow::STAGING_REPOSITORY_UNSUPPORTED:
	+ return array(
	+ 'title' => pht('Repository Unsupported'),
	+ 'body' => pht(
	+ 'When this diff was generated, the server was running an older '.
	+ 'version of Phabricator which did not support staging areas for '.
	+ 'this version control system, so the chagne was not pushed to '.
	+ 'staging. Changes must be pushed to staging before they can be '.
	+ 'landed from the web.'),
	+ );
	+
	+ case ArcanistDiffWorkflow::STAGING_REPOSITORY_UNCONFIGURED:
	+ return array(
	+ 'title' => pht('Repository Unconfigured'),
	+ 'body' => pht(
	+ 'When this diff was generated, the repository was not configured '.
	+ 'with a staging area, so the change was not pushed to staging. '.
	+ 'Changes must be pushed to staging before they can be landed '.
	+ 'from the web.'),
	+ );
	+ case ArcanistDiffWorkflow::STAGING_CLIENT_UNSUPPORTED:
	+ return array(
	+ 'title' => pht('Client Support Unavailable'),
	+ 'body' => pht(
	+ 'When this diff was generated, the client did not support '.
	+ 'staging areas for this version control system, so the change '.
	+ 'was not pushed to staging. Changes must be pushed to staging '.
	+ 'before they can be landed from the web. Updating the client '.
	+ 'may resolve this issue.'),
	+ );
	+ default:
	+ return array(
	+ 'title' => pht('Unknown Error'),
	+ 'body' => pht(
	+ 'When this diff was generated, it was not pushed to staging for '.
	+ 'an unknown reason (the status code was "%s"). Changes must be '.
	+ 'pushed to staging before they can be landed from the web. '.
	+ 'The server may be running an out-of-date version of Phabricator, '.
	+ 'and updating may provide more information about this error.',
	+ $status),
	+ );
	+ }
	+ }
	+
	}
	diff --git a/src/applications/harbormaster/storage/build/HarbormasterBuildLog.php b/src/applications/harbormaster/storage/build/HarbormasterBuildLog.php
	index 40090d0ac3..290b288c6c 100644
	--- a/src/applications/harbormaster/storage/build/HarbormasterBuildLog.php
	+++ b/src/applications/harbormaster/storage/build/HarbormasterBuildLog.php
	@@ -1,304 +1,306 @@
	<?php

	final class HarbormasterBuildLog
	extends HarbormasterDAO
	implements PhabricatorPolicyInterface {

	protected $buildTargetPHID;
	protected $logSource;
	protected $logType;
	protected $duration;
	protected $live;

	private $buildTarget = self::ATTACHABLE;
	private $rope;
	private $isOpen;

	const CHUNK_BYTE_LIMIT = 102400;

	public function __construct() {
	$this->rope = new PhutilRope();
	}

	public function __destruct() {
	if ($this->isOpen) {
	$this->closeBuildLog();
	}
	}

	public static function initializeNewBuildLog(
	HarbormasterBuildTarget $build_target) {

	return id(new HarbormasterBuildLog())
	->setBuildTargetPHID($build_target->getPHID())
	->setDuration(null)
	->setLive(0);
	}

	public function openBuildLog() {
	if ($this->isOpen) {
	throw new Exception(pht('This build log is already open!'));
	}

	$this->isOpen = true;

	return $this
	->setLive(1)
	->save();
	}

	public function closeBuildLog() {
	if (!$this->isOpen) {
	throw new Exception(pht('This build log is not open!'));
	}

	if ($this->canCompressLog()) {
	$this->compressLog();
	}

	$start = $this->getDateCreated();
	$now = PhabricatorTime::getNow();

	return $this
	->setDuration($now - $start)
	->setLive(0)
	->save();
	}


	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	// T6203/NULLABILITY
	// It seems like these should be non-nullable? All logs should have a
	// source, etc.
	'logSource' => 'text255?',
	'logType' => 'text255?',
	'duration' => 'uint32?',

	'live' => 'bool',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_buildtarget' => array(
	'columns' => array('buildTargetPHID'),
	),
	),
	) + parent::getConfiguration();
	}

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

	public function attachBuildTarget(HarbormasterBuildTarget $build_target) {
	$this->buildTarget = $build_target;
	return $this;
	}

	public function getBuildTarget() {
	return $this->assertAttached($this->buildTarget);
	}

	public function getName() {
	return pht('Build Log');
	}

	public function append($content) {
	if (!$this->getLive()) {
	throw new PhutilInvalidStateException('openBuildLog');
	}

	$content = (string)$content;

	$this->rope->append($content);
	$this->flush();
	+
	+ return $this;
	}

	private function flush() {

	// TODO: Maybe don't flush more than a couple of times per second. If a
	// caller writes a single character over and over again, we'll currently
	// spend a lot of time flushing that.

	$chunk_table = id(new HarbormasterBuildLogChunk())->getTableName();
	$chunk_limit = self::CHUNK_BYTE_LIMIT;
	$encoding_text = HarbormasterBuildLogChunk::CHUNK_ENCODING_TEXT;

	$rope = $this->rope;

	while (true) {
	$length = $rope->getByteLength();
	if (!$length) {
	break;
	}

	$conn_w = $this->establishConnection('w');
	$last = $this->loadLastChunkInfo();

	$can_append =
	($last) &&
	($last['encoding'] == $encoding_text) &&
	($last['size'] < $chunk_limit);
	if ($can_append) {
	$append_id = $last['id'];
	$prefix_size = $last['size'];
	} else {
	$append_id = null;
	$prefix_size = 0;
	}

	$data_limit = ($chunk_limit - $prefix_size);
	$append_data = $rope->getPrefixBytes($data_limit);
	$data_size = strlen($append_data);

	if ($append_id) {
	queryfx(
	$conn_w,
	'UPDATE %T SET chunk = CONCAT(chunk, %B), size = %d WHERE id = %d',
	$chunk_table,
	$append_data,
	$prefix_size + $data_size,
	$append_id);
	} else {
	$this->writeChunk($encoding_text, $data_size, $append_data);
	}

	$rope->removeBytesFromHead($data_size);
	}
	}

	public function newChunkIterator() {
	return id(new HarbormasterBuildLogChunkIterator($this))
	->setPageSize(32);
	}

	private function loadLastChunkInfo() {
	$chunk_table = new HarbormasterBuildLogChunk();
	$conn_w = $chunk_table->establishConnection('w');

	return queryfx_one(
	$conn_w,
	'SELECT id, size, encoding FROM %T WHERE logID = %d
	ORDER BY id DESC LIMIT 1',
	$chunk_table->getTableName(),
	$this->getID());
	}

	public function getLogText() {
	// TODO: Remove this method since it won't scale for big logs.

	$all_chunks = $this->newChunkIterator();

	$full_text = array();
	foreach ($all_chunks as $chunk) {
	$full_text[] = $chunk->getChunkDisplayText();
	}

	return implode('', $full_text);
	}

	private function canCompressLog() {
	return function_exists('gzdeflate');
	}

	public function compressLog() {
	$this->processLog(HarbormasterBuildLogChunk::CHUNK_ENCODING_GZIP);
	}

	public function decompressLog() {
	$this->processLog(HarbormasterBuildLogChunk::CHUNK_ENCODING_TEXT);
	}

	private function processLog($mode) {
	$chunks = $this->newChunkIterator();

	// NOTE: Because we're going to insert new chunks, we need to stop the
	// iterator once it hits the final chunk which currently exists. Otherwise,
	// it may start consuming chunks we just wrote and run forever.
	$last = $this->loadLastChunkInfo();
	if ($last) {
	$chunks->setRange(null, $last['id']);
	}

	$byte_limit = self::CHUNK_BYTE_LIMIT;
	$rope = new PhutilRope();

	$this->openTransaction();

	foreach ($chunks as $chunk) {
	$rope->append($chunk->getChunkDisplayText());
	$chunk->delete();

	while ($rope->getByteLength() > $byte_limit) {
	$this->writeEncodedChunk($rope, $byte_limit, $mode);
	}
	}

	while ($rope->getByteLength()) {
	$this->writeEncodedChunk($rope, $byte_limit, $mode);
	}

	$this->saveTransaction();
	}

	private function writeEncodedChunk(PhutilRope $rope, $length, $mode) {
	$data = $rope->getPrefixBytes($length);
	$size = strlen($data);

	switch ($mode) {
	case HarbormasterBuildLogChunk::CHUNK_ENCODING_TEXT:
	// Do nothing.
	break;
	case HarbormasterBuildLogChunk::CHUNK_ENCODING_GZIP:
	$data = gzdeflate($data);
	if ($data === false) {
	throw new Exception(pht('Failed to gzdeflate() log data!'));
	}
	break;
	default:
	throw new Exception(pht('Unknown chunk encoding "%s"!', $mode));
	}

	$this->writeChunk($mode, $size, $data);

	$rope->removeBytesFromHead($size);
	}

	private function writeChunk($encoding, $raw_size, $data) {
	return id(new HarbormasterBuildLogChunk())
	->setLogID($this->getID())
	->setEncoding($encoding)
	->setSize($raw_size)
	->setChunk($data)
	->save();
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


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

	public function getPolicy($capability) {
	return $this->getBuildTarget()->getPolicy($capability);
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getBuildTarget()->hasAutomaticCapability(
	$capability,
	$viewer);
	}

	public function describeAutomaticCapability($capability) {
	return pht(
	"Users must be able to see a build target to view it's build log.");
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 27, 2:01 PM (1 w, 5 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 184621
Default Alt Text: (27 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions