public function process()
{
$parameters = $this->getParametersAsArray();
if (!empty($parameters[0])) {
$repository_id = (int) $parameters[0];
} else {
$this->error('Missing argument repository id');
return false;
}
if (!empty($parameters[1])) {
$remote_server_id = (int) $parameters[1];
} else {
$this->error('Missing argument remote server id');
return false;
}
$repository = $this->repository_factory->getRepositoryById($repository_id);
if (!$repository) {
$this->error('Failed to find repository ' . $repository_id);
return false;
}
$server = $this->server_factory->getServerById($remote_server_id);
if (!$server) {
$this->error('Failed to find server ' . $remote_server_id);
return false;
}
$project = $repository->getProject();
if (!$project) {
$this->error('Failed to find project ' . $repository->getProject());
return false;
}
return $this->makeGerritProjectReadOnly($repository, $server, $project);
}
public function process()
{
$parameters = $this->getParametersAsArray();
//project id
$projectId = 0;
if (!empty($parameters[0])) {
$projectId = (int) $parameters[0];
} else {
$this->error('Missing argument project id');
return false;
}
//repo id
$repositoryId = 0;
if (!empty($parameters[1])) {
$repositoryId = (int) $parameters[1];
} else {
$this->error('Missing argument repository id');
return false;
}
$repository = $this->repository_factory->getDeletedRepository($repositoryId);
if ($repository->getProjectId() != $projectId) {
$this->error('Bad project id');
return false;
}
return $this->deleteRepo($repository, $projectId, $parameters);
}
public function deleteRepository($projectId, $repositoryId)
{
$c = $this->getController();
$projectId = intval($projectId);
$repositoryId = intval($repositoryId);
if (empty($projectId) || empty($repositoryId)) {
$c->addError($this->getText('actions_params_error'));
return false;
}
$repository = $this->factory->getRepositoryById($repositoryId);
if ($repository) {
if ($repository->canBeDeleted()) {
$this->markAsDeleted($repository);
$c->addInfo($this->getText('actions_delete_process'));
$c->addInfo($this->getText('actions_delete_backup') . ' : ' . $c->getPlugin()->getConfigurationParameter('git_backup_dir'));
} else {
$c->addError($this->getText('backend_delete_haschild_error'));
$c->redirect('/plugins/git/index.php/' . $projectId . '/view/' . $repositoryId . '/');
return false;
}
} else {
$c->addError($this->getText('actions_repo_not_found'));
}
$c->redirect('/plugins/git/?action=index&group_id=' . $projectId);
}
/**
* Constructor.
*
* @param Integer $groupId Project Id
* @param Integer $weeksNumber Statistics duration in weeks
*
* @return Void
*/
public function __construct($groupId, $weeksNumber)
{
$dao = new GitDao();
// TODO: Optionally include presonal forks in repo list
$allRepositories = $dao->getProjectRepositoryList($groupId);
$um = UserManager::instance();
$user = $um->getCurrentUser();
$repoFactory = new GitRepositoryFactory($dao, ProjectManager::instance());
foreach ($allRepositories as $repo) {
$repository = $repoFactory->getRepositoryById($repo['repository_id']);
if ($repository->userCanRead($user)) {
$this->repoList[] = $repository;
}
}
$this->displayChart = false;
$this->weeksNumber = min($weeksNumber, self::MAX_WEEKSNUMBER);
// Init some class properties according to 'weeks number' parameter
$today = $_SERVER['REQUEST_TIME'];
$startPeriod = strtotime("-{$this->weeksNumber} weeks");
$weekInSeconds = self::WEEKS_IN_SECONDS;
for ($i = $startPeriod + $weekInSeconds; $i < $today + $weekInSeconds; $i += $weekInSeconds) {
$this->dates[] = date('M d', $i);
$this->weekNum[] = intval(date('W', $i));
$this->year[] = intval(date('Y', $i));
}
}
/**
* Delete all project repositories (on project deletion).
*
* @param Project $project
*/
public function deleteProjectRepositories(Project $project)
{
$repositories = $this->repository_factory->getAllRepositories($project);
foreach ($repositories as $repository) {
$repository->forceMarkAsDeleted();
$this->system_event_manager->createEvent('GIT_REPO_DELETE', $project->getID() . SystemEvent::PARAMETER_SEPARATOR . $repository->getId(), SystemEvent::PRIORITY_MEDIUM);
}
}
/**
* Store details about the push in the DB
*
* @param String $repositoryLocation Name of the git repository
* @param String $identifier Name of the gitshell user that performed the push, retrived from whoami output.
* @param Integer $pushTimestamp Date of the commit
* @param Integer $commitsNumber Number of commits
* @param String $gitoliteUser Name of the gitolite user that performed the push, retrived from environment var $GL_USER.
*
* @return void
*/
function logGitPushes($repositoryLocation, $identifier, $pushTimestamp, $commitsNumber, $gitoliteUser)
{
$repoFactory = new GitRepositoryFactory(new GitDao(), ProjectManager::instance());
$repository = $repoFactory->getFromFullPath($repositoryLocation);
if ($repository) {
$repository->logGitPush($identifier, $pushTimestamp, $commitsNumber, $gitoliteUser);
}
}
public function execute($repository_path, $user_name, $oldrev, $newrev, $refname)
{
$repository = $this->repository_factory->getFromFullPath($repository_path);
if ($repository !== null) {
$user = $this->user_manager->getUserByUserName($user_name);
if ($user === null) {
$user = new PFUser(array('user_id' => 0));
}
$this->executeForRepositoryAndUser($repository, $user, $oldrev, $newrev, $refname);
}
}
/**
* Save on filesystem all permission configuration for a project
*
* @param Project $project
*/
public function dumpProjectRepoConf(Project $project)
{
$this->logger->debug("Dumping project repo conf for:Â " . $project->getUnixName());
$project_config = '';
foreach ($this->repository_factory->getAllRepositoriesOfProject($project) as $repository) {
$this->logger->debug("Fetching Repo Configuration:Â " . $repository->getName() . "...");
$project_config .= $this->fetchReposConfig($project, $repository);
$this->logger->debug("Fetching Repo Configuration:Â " . $repository->getName() . ": done");
}
return $project_config;
}
/**
* Trigger jobs corresponding to the Git repository
*
* @param String $repositoryLocation Name of the git repository
*
* @return Void
*/
function triggerCiBuild($repositoryLocation)
{
$pm = ProjectManager::instance();
$repoFactory = new GitRepositoryFactory(new GitDao(), $pm);
$repository = $repoFactory->getFromFullPath($repositoryLocation);
if ($repository) {
if ($repository->getProject()->usesService('hudson')) {
$gitCi = new Git_CI();
$gitCi->triggerCiBuild($repository->getId());
}
}
}
function testGetRepositoryFromFullPathAndGitRoot()
{
$dao = new MockGitDao();
$projectManager = new MockProjectManager();
$project = new MockProject();
$project->setReturnValue('getID', 101);
$project->setReturnValue('getUnixName', 'garden');
$projectManager->setReturnValue('getProjectByUnixName', $project, array('garden'));
$factory = new GitRepositoryFactory($dao, $projectManager);
$dao->expectOnce('searchProjectRepositoryByPath', array(101, 'garden/diskinstaller.git'));
$dao->setReturnValue('searchProjectRepositoryByPath', new MockDataAccessResult());
$factory->getFromFullPath('/data/tuleap/gitroot/garden/diskinstaller.git');
}
/**
* Return a reference that match keyword and value
* @param Project $project
* @param String $keyword
* @param String $value
* @return Reference
*/
public function getReference(Project $project, $keyword, $value)
{
$reference = false;
list($repository_name, $sha1) = $this->splitRepositoryAndSha1($value);
$repository = $this->repository_factory->getRepositoryByPath($project->getId(), $project->getUnixName() . '/' . $repository_name . '.git');
if ($repository) {
$args = array($repository->getId(), $sha1);
$reference = $this->reference_manager->loadReferenceFromKeywordAndNumArgs($keyword, $project->getID(), count($args), $value);
if ($reference) {
$reference->setLink($reference->getLink() . '&p=' . $repository_name);
$reference->replaceLink($args);
}
}
return $reference;
}
public function process()
{
$repository = $this->getRepositoryFromParameters();
if (!$repository) {
if ($this->repository_factory->getDeletedRepository($this->getRepositoryIdFromParameters())) {
$this->done('Unable to update a repository marked as deleted');
return;
}
$this->warning('Unable to find repository, perhaps it was deleted in the mean time?');
return;
}
$this->system_event_manager->queueGrokMirrorManifest($repository);
$repository->getBackend()->updateRepoConf($repository);
$this->done();
}
/**
* Note: for a newly developed feature, it would be better to have a dedicated
* queue for root event but
* - The events below are meant to disapear when legacy backend will be removed
* - This mean that for all new platforms there would be a new empty pane (git root
* events)
* So it's better to make them run in the default queue like before
*/
public function getTypesForDefaultQueue()
{
if ($this->repository_factory->hasGitShellRepositories()) {
return array(SystemEvent_GIT_LEGACY_REPO_ACCESS::NAME, SystemEvent_GIT_LEGACY_REPO_DELETE::NAME);
}
return array();
}
public function createReference($projectId, $repositoryName)
{
// Uncomment the following line only for debug prupose if you ever need to
// create a gitshell repo (good luck, luke, may the force be with you).
//$this->createGitshellReference($projectId, $repositoryName);
$c = $this->getController();
$projectId = intval($projectId);
$repository = new GitRepository();
$repository->setBackend(new Git_Backend_Gitolite(new Git_GitoliteDriver()));
if ($repository->isNameValid($repositoryName) === false) {
$c->addError($this->getText('actions_input_format_error', array($repository->getBackend()->getAllowedCharsInNamePattern(), GitDao::REPO_NAME_MAX_LENGTH)));
$c->redirect('/plugins/git/?action=index&group_id=' . $projectId);
return false;
}
$project = ProjectManager::instance()->getProject($projectId);
$repository->setDescription('-- Default description --');
$repository->setCreator(UserManager::instance()->getCurrentUser());
$repository->setProject($project);
$repository->setName($repositoryName);
if (!$this->factory->isRepositoryExistingByName($project, $repositoryName)) {
$repository->create();
} else {
$c->addError($this->getText('actions_create_repo_exists', array($repositoryName)));
}
$c->redirect('/plugins/git/?action=index&group_id=' . $projectId);
return;
}
private function getRepositoriesFromIds(array $repoIds)
{
$repos = array();
foreach ($repoIds as $id) {
$repos[] = $this->factory->getRepositoryById($id);
}
return $repos;
}
public function fetchAllProjectRepositoriesForMirror(Git_Mirror_Mirror $mirror, array $project_ids)
{
$rows = $this->dao->fetchAllProjectRepositoriesForMirror($mirror->id, $project_ids);
$repositories = array();
foreach ($rows as $row) {
$repositories[] = $this->repository_factory->instanciateFromRow($row);
}
return $repositories;
}
/**
* Prepare fork repository message
*
* @param String $repos Comma separated repositories Ids selected for fork
*
* @return String
*/
private function displayForkSourceRepositories($repos)
{
$dao = new GitDao();
$repoFactory = new GitRepositoryFactory($dao, $this->getProjectManager());
$sourceReposHTML = '';
$repositories = explode(',', $repos);
foreach ($repositories as $repositoryId) {
$repository = $repoFactory->getRepositoryById($repositoryId);
$sourceReposHTML .= '"' . $this->getPurifier()->purify($repository->getFullName()) . '" ';
}
return $sourceReposHTML;
}
private function verbalizeRepoId($repo_id, $with_link)
{
$txt = '#' . $repo_id;
if ($with_link) {
$hp = Codendi_HTMLPurifier::instance();
$repo = $this->repository_factory->getRepositoryById($repo_id);
if ($repo) {
$txt = $repo->getHTMLLink($this->url_manager);
}
}
return $txt;
}
private function getRepositoriesFromIds($repository_ids)
{
$repositories = array();
foreach ($repository_ids as $repository_id) {
$repository = $this->factory->getRepositoryById($repository_id);
if (!$repository) {
return false;
}
$repositories[] = $repository;
}
return $repositories;
}
/**
*
* Get archived Gitolite repositories for restore
*
* @param Int $project_id
*
* @return GitRepository[]
*/
public function getRepositoriesForRestoreByProjectId($project_id)
{
$archived_repositories = array();
$retention_period = intval($GLOBALS['sys_file_deletion_delay']);
$deleted_repositories = $this->repository_factory->getDeletedRepositoriesByProjectId($project_id, $retention_period);
foreach ($deleted_repositories as $repository) {
$archive = realpath($this->backup_directory . '/' . $repository->getBackupPath() . ".tar.gz");
if (file_exists($archive)) {
array_push($archived_repositories, $repository);
}
}
return $archived_repositories;
}
private function importRepository(Project $project, PFUser $creator, SimpleXMLElement $repository_xmlnode, $extraction_path)
{
$repository_info = $repository_xmlnode->attributes();
$this->logger->debug("Importing {$repository_info['name']} using {$repository_info['bundle-path']}");
$description = isset($repository_info['description']) ? (string) $repository_info['description'] : GitRepository::DEFAULT_DESCRIPTION;
$repository = $this->repository_factory->buildRepository($project, $repository_info['name'], $creator, $this->gitolite_backend, $description);
$absolute_bundle_path = $extraction_path . '/' . $repository_info['bundle-path'];
$extraction_path_arg = escapeshellarg($extraction_path);
$this->system_command->exec("chmod 755 {$extraction_path_arg}");
$this->repository_manager->createFromBundle($repository, $this->gitolite_backend, $absolute_bundle_path);
$this->importPermissions($project, $repository_xmlnode->children(), $repository);
$this->system_event_manager->queueProjectsConfigurationUpdate(array($project->getGroupId()));
}
/**
* @return GitRepository|null
*/
private function getRepositoryFromStandardURL()
{
$repository_id = $this->matches['repository_id'];
$repository_id_is_a_int = preg_match('/^([0-9]+)$/', $repository_id);
if ($repository_id_is_a_int) {
return $this->repository_factory->getRepositoryById($repository_id);
} else {
$project = $this->getProjectFromStandardURL();
if (!$project->isError()) {
return $this->repository_factory->getRepositoryByPath($project->getID(), GitRepository::getPathFromProjectAndName($project, $repository_id));
}
}
return null;
}
public function restoreRepository($repo_id, $project_id)
{
$repository = $this->factory->getDeletedRepository($repo_id);
$url = '/admin/show_pending_documents.php?group_id=' . $project_id . '&focus=git_repository';
if (!$repository) {
$GLOBALS['Response']->addFeedback('error', $GLOBALS['Language']->getText('plugin_git', 'restore_invalid_id'));
$GLOBALS['Response']->redirect($url);
}
$active_repository = $this->factory->getRepositoryByPath($project_id, $repository->getPath());
if ($active_repository instanceof GitRepository) {
$GLOBALS['Response']->addFeedback('error', $GLOBALS['Language']->getText('plugin_git', 'restore_invalid_name'));
} else {
$this->git_system_event_manager->queueRepositoryRestore($repository);
$GLOBALS['Response']->addFeedback('info', $GLOBALS['Language']->getText('plugin_git', 'restore_event_created') . ' : ' . $repository->getName());
}
$GLOBALS['Response']->redirect($url);
}
/**
* Return true if proposed name already exists as a repository path
*
* @param Project $project
* @param String $name
*
* @return Boolean
*/
public function isRepositoryNameAlreadyUsed(GitRepository $new_repository)
{
$repositories = $this->repository_factory->getAllRepositories($new_repository->getProject());
foreach ($repositories as $existing_repo) {
$new_repo_path = $new_repository->getPathWithoutLazyLoading();
$existing_repo_path = $existing_repo->getPathWithoutLazyLoading();
if ($new_repo_path == $existing_repo_path) {
return true;
}
if ($this->nameIsSubPathOfExistingRepository($existing_repo_path, $new_repo_path)) {
return true;
}
if ($this->nameAlreadyExistsAsPath($existing_repo_path, $new_repo_path)) {
return true;
}
}
}
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Tuleap is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tuleap. If not, see <http://www.gnu.org/licenses/>.
*/
require_once 'pre.php';
$git_dao = new GitDao();
$user_manager = UserManager::instance();
$git_repository_factory = new GitRepositoryFactory($git_dao, ProjectManager::instance());
$system_event_manager = new Git_SystemEventManager(SystemEventManager::instance(), $git_repository_factory);
$git_plugin = PluginManager::instance()->getPluginByName('git');
$logger = $git_plugin->getLogger();
if ($argv[1] == "--init") {
$repository_path = $argv[2];
$user_name = $argv[3];
$repository = $git_repository_factory->getFromFullPath($repository_path);
if ($repository) {
$system_event_manager->queueGrokMirrorManifestFollowingAGitPush($repository);
}
} else {
$repository_path = $argv[1];
$user_name = $argv[2];
$old_rev = $argv[3];
$new_rev = $argv[4];
private function getRepositoryFromParameters()
{
return $this->repository_factory->getRepositoryById($this->getRepositoryIdFromParameters());
}
/**
* Gives the parent GitRepository object of this
* Look into the database
* @return GitRepository
*/
public function getParent()
{
if (empty($this->parent)) {
$factory = new GitRepositoryFactory($this->getDao(), $this->_getProjectManager());
$this->parent = $factory->getRepositoryById($this->getParentId());
}
return $this->parent;
}
