/** * Process stored event */ function process() { list($group_id, $shortname, $is_used) = $this->getParametersAsArray(); if ($project = $this->getProject($group_id)) { // If 'CVS' was activated, create the repo (if it does not exist) and regenerate cvs_root_allow. // if 'CVS' was inactivated... keep the repository, and do nothing. if ($shortname == 'cvs' && $is_used) { // This function will not create the repo if it already exists if (!Backend::instance('CVS')->createProjectCVS($group_id)) { $this->error("Could not create CVS repo for project {$group_id} after service activation"); return false; } Backend::instance('CVS')->setCVSRootListNeedUpdate(); } // Same as for CVS. if ($shortname == 'svn' && $is_used) { $backendSVN = Backend::instance('SVN'); if (!$backendSVN->createProjectSVN($group_id)) { $this->error("Could not create SVN repo for project {$group_id} after service activation"); return false; } $backendSVN->setSVNApacheConfNeedUpdate(); } $this->done(); return true; } return false; }
public function process() { global $sys_allow_restricted_users; $parameters = $this->getParametersAsArray(); $project = null; if (!empty($parameters[0])) { $project = $this->getProject($parameters[0]); } else { $this->error('Missing argument project id'); return false; } $repositoryName = ''; if (!empty($parameters[1])) { $repositoryName = $parameters[1]; } else { $this->error('Missing argument repository name'); return false; } $userId = 0; if (!empty($parameters[2])) { $userId = $parameters[2]; } else { $this->error('Missing argument user id'); return false; } try { $repository = new GitRepository(); $repository->setBackend(Backend::instance('Git', 'GitBackend')); $repository->setDescription('-- Default description --'); //default access is private when restricted users are allowed if ($sys_allow_restricted_users == 1) { $repository->setAccess(GitRepository::PRIVATE_ACCESS); } else { $repository->setAccess(GitRepository::PUBLIC_ACCESS); } $user = null; if (!empty($userId)) { $user = UserManager::instance()->getUserById($userId); } if (!empty($user)) { $repository->setCreator($user); } $repository->setProject($project); $repository->setName($repositoryName); $repository->create(); $this->done(); } catch (GitDaoException $e) { $this->error($e->getMessage()); return false; } catch (GitDriverException $e) { $this->error($e->getMessage()); return false; } catch (GitBackendException $e) { $this->error($e->getMessage()); return false; } catch (Exception $e) { $this->error($e->getMessage()); return false; } }
/** * Perform user creation on system * * @param PFUser $user * * @return Boolean */ private function createUser(PFUser $user) { Backend::instance('Aliases')->setNeedUpdateMailAliases(); $system_backend = Backend::instance('System'); $system_backend->flushNscdAndFsCache(); return $system_backend->createUserHome($user); }
public function getProcessForQueue($request_queue) { $owner = SystemEvent::OWNER_APP; $custom_queues = array(); $this->event_manager->processEvent(Event::SYSTEM_EVENT_GET_CUSTOM_QUEUES, array('queues' => &$custom_queues)); if (isset($custom_queues[$request_queue])) { $this->logger = $custom_queues[$request_queue]->getLogger(); $this->logger->debug('Processing ' . $request_queue . ' queue.'); $process = new SystemEventProcessCustomQueue($request_queue); $owner = $custom_queues[$request_queue]->getOwner(); } else { switch ($request_queue) { case SystemEvent::OWNER_APP: $this->logger->debug('Processing default queue as app user.'); $process = new SystemEventProcessApplicationOwnerDefaultQueue(); break; case SystemEvent::DEFAULT_QUEUE: $this->logger->debug('Processing default queue as root user.'); $owner = SystemEvent::OWNER_ROOT; $process = new SystemEventProcessRootDefaultQueue(); break; default: $this->logger->debug('Ignoring ' . $request_queue . ' queue.'); exit(0); } } if ($owner === SystemEvent::OWNER_APP) { return new SystemEventProcessor_ApplicationOwner($process, $this->system_event_manager, new SystemEventDao(), $this->logger); } return new SystemEventProcessor_Root($process, $this->system_event_manager, new SystemEventDao(), $this->logger, Backend::instance('Aliases'), Backend::instance('CVS'), Backend::instance('SVN'), Backend::instance('System'), new SiteCache($this->logger)); }
public static function Instance() { if (self::$instance == null) { self::$instance = new Backend(); } return self::$instance; }
public function process() { // Need to update aliases Backend::instance('Aliases')->setNeedUpdateMailAliases(); $this->done(); return true; }
/** * Process stored event */ function process() { list($group_id, $project_is_private) = $this->getParametersAsArray(); if ($project = $this->getProject($group_id)) { if ($project->usesCVS()) { if (!Backend::instance('CVS')->setCVSPrivacy($project, $project_is_private)) { $this->error("Could not set cvs privacy for project {$group_id}"); return false; } } if ($project->usesSVN()) { $backendSVN = Backend::instance('SVN'); if (!$backendSVN->setSVNPrivacy($project, $project_is_private)) { $this->error("Could not set svn privacy for project {$group_id}"); return false; } if (!$backendSVN->updateSVNAccess($group_id)) { $this->error("Could not update svn access file for project {$group_id}"); return false; } } //allows to link plugins to this system event $this->callSystemEventListeners(__CLASS__); $this->done(); return true; } return false; }
/** * Process stored event */ function process() { list($group_id, $user_id) = $this->getParametersAsArray(); if ($project = $this->getProject($group_id)) { if ($user_id == 0) { return $this->setErrorBadParam(); } // CVS writers if ($project->usesCVS()) { if (!Backend::instance('CVS')->updateCVSwriters($group_id)) { $this->error("Could not update CVS writers for group {$group_id}"); return false; } } // SVN access file if ($project->usesSVN()) { if (!Backend::instance('SVN')->updateSVNAccess($group_id)) { $this->error("Could not update SVN access file ({$group_id})"); return false; } } // Need to update system group cache Backend::instance('System')->setNeedRefreshGroupCache(); $this->done(); return true; } return false; }
/** * Some files might have been generated as root but should be owned by codendiadm */ public function restoreOwnership() { $backend = Backend::instance(); $this->logger->debug("Restore ownership to " . $GLOBALS['Language']->getCacheDirectory()); $backend->recurseChownChgrp($GLOBALS['Language']->getCacheDirectory(), ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user')); $plugin_manager = PluginManager::instance(); $this->logger->debug("Restore ownership to " . $plugin_manager->getCacheFile()); $backend->changeOwnerGroupMode($plugin_manager->getCacheFile(), ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user'), 0600); }
/** * Return a Backend instance * * Let plugins propose their own backend. If none provided, use the default one. * * @return Backend */ public static function getBackend() { $backend = null; $params = array('backend' => &$backend); EventManager::instance()->processEvent('backend_factory_get_backend', $params); if ($backend === null) { $backend = Backend::instance(); } return $backend; }
public function get_system_event_class($params) { switch ($params['type']) { case 'SVN_CREATE_REPOSITORY': include_once dirname(__FILE__) . '/events/SystemEvent_SVN_CREATE_REPOSITORY.class.php'; $params['class'] = 'SystemEvent_SVN_CREATE_REPOSITORY'; $params['dependencies'] = array(Backend::instance(Backend::SVN)); break; } }
public function tearDown() { parent::tearDown(); EventManager::clearInstance(); unset($GLOBALS['homedir_prefix']); $backend = Backend::instance(); $backend->recurseDeleteInDir($this->toto_home); rmdir($this->toto_home); $backend->recurseDeleteInDir($this->foobar_home); rmdir($this->foobar_home); }
public function process() { $user_id = $this->getIdFromParam($this->parameters); if ($user = UserManager::instance()->getUserById($user_id)) { if (!Backend::instance('System')->dumpSSHKeysForUser($user)) { $this->error("Could not dump ssh keys for user " . $user->getUserName()); return false; } } else { $this->error("Could not create/initialize user object"); return false; } $this->done(); return true; }
/** * Process stored event */ function process() { list($group_id, $cvs_is_private) = $this->getParametersAsArray(); if ($project = $this->getProject($group_id)) { if ($project->usesCVS()) { if (!Backend::instance('CVS')->setCVSPrivacy($project, $cvs_is_private)) { $this->error("Could not set cvs is private for group {$group_id}"); return false; } } $this->done(); return true; } return false; }
/** * Process stored event */ function process() { // Check parameters $group_list_id = $this->getIdFromParam($this->parameters); if ($group_list_id == 0) { return $this->setErrorBadParam(); } if (!Backend::instance('MailingList')->createList($group_list_id)) { $this->error("Could not create mailing list {$group_list_id}"); return false; } // Need to add list aliases Backend::instance('Aliases')->setNeedUpdateMailAliases(); $this->done(); return true; }
/** * Some files might have been generated as root but should be owned by codendiadm */ public function restoreOwnership() { $backend = Backend::instance(); $cache_directory = ForgeConfig::get('codendi_cache_dir'); $this->logger->debug('Restore ownership to ' . $cache_directory); $backend->changeOwnerGroupMode($cache_directory, ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user'), 0750); $combined_cache_directory = ForgeConfig::get('sys_combined_dir'); $this->logger->debug('Restore ownership to ' . $combined_cache_directory); $backend->recurseChownChgrp($combined_cache_directory, ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user')); $language_cache_directory = $GLOBALS['Language']->getCacheDirectory(); $this->logger->debug('Restore ownership to ' . $language_cache_directory); $backend->recurseChownChgrp($language_cache_directory, ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user')); $plugin_manager = PluginManager::instance(); $plugin_cache_file = $plugin_manager->getCacheFile(); $this->logger->debug('Restore ownership to ' . $plugin_cache_file); $backend->changeOwnerGroupMode($plugin_cache_file, ForgeConfig::get('sys_http_user'), ForgeConfig::get('sys_http_user'), 0600); }
/** * Process stored event */ function process() { // Check parameters $user_id = $this->getIdFromParam($this->parameters); if ($user_id == 0) { return $this->setErrorBadParam(); } // Need to remove user alias Backend::instance('Aliases')->setNeedUpdateMailAliases(); // Archive user home directory if (!Backend::instance('System')->archiveUserHome($user_id)) { $this->error("Could not archive user home"); return false; } $this->done(); return true; }
/** * Process stored event */ public function process() { // Re-dumping ssh keys should be done only once a day as: // - It's I/O intensive // - It's stress gitolite backend // - SSH keys should already be dumped via EDIT_SSH_KEY event $backend_system = Backend::instance('System'); $backend_system->dumpSSHKeys(); // User home sanity check should be done only once a day as // it is slooow (due to libnss-mysql) $this->userHomeSanityCheck($backend_system); try { $this->_getEventManager()->processEvent('root_daily_start', array()); $this->done(); } catch (Exception $e) { $this->error($e->getMessage()); } return true; }
public static function singleton() { if (!isset(self::$instance)) { $backend = Config::singleton()->Backend; if(!$backend) { throw new BackendNotSpecifiedException("Backend type not specified, please specify one in the config."); } // The backend type is supplied by the code, so we don't bother to check if the file exists // (it will simply throw an error if it doesn't). require_once($_SERVER["DOCUMENT_ROOT"] . 'includes/framework/backends/class.'.$backend.'Backend.php'); $c = $backend.'Backend'; self::$instance = new $c; } return self::$instance; }
/** * Process stored event */ function process() { $ugroup_name = null; $ugroup_old_name = null; // Check parameters if (count($this->getParametersAsArray()) == 4) { list($group_id, $ugroup_id, $ugroup_name, $ugroup_old_name) = $this->getParametersAsArray(); } else { list($group_id, $ugroup_id) = $this->getParametersAsArray(); } if ($project = $this->getProject($group_id)) { // Update SVN access file if ($project->usesSVN()) { $backendSVN = Backend::instance('SVN'); if (!$backendSVN->updateSVNAccess($group_id, $ugroup_name, $ugroup_old_name)) { $this->error("Could not update SVN access file ({$group_id})"); return false; } } } $this->done(); return true; }
/** * Process stored event */ function process() { $groups = explode(',', $this->parameters); $backendSystem = Backend::instance('System'); // Force NSCD flush (otherwise uid & gid will not exist) $backendSystem->flushNscdAndFsCache(); foreach ($groups as $group_id) { if ($project = $this->getProject($group_id)) { if (!$backendSystem->createProjectHome($group_id)) { $this->error("Could not create project home"); return false; } if ($project->usesCVS()) { $backendCVS = Backend::instance('CVS'); if (!$backendCVS->createProjectCVS($group_id)) { $this->error("Could not create/initialize project CVS repository"); return false; } $backendCVS->setCVSRootListNeedUpdate(); $backendCVS->setCVSPrivacy($project, !$project->isPublic() || $project->isCVSPrivate()); } if ($project->usesSVN()) { $backendSVN = Backend::instance('SVN'); if (!$backendSVN->createProjectSVN($group_id)) { $this->error("Could not create/initialize project SVN repository"); return false; } $backendSVN->setSVNApacheConfNeedUpdate(); $backendSVN->setSVNPrivacy($project, !$project->isPublic()); } $backendSystem->log("Project " . $project->getUnixName() . " created"); } } $this->done(); return true; }
/** * Instantiate a SystemEvent from a row * * @param array $row The data of the event * * @return SystemEvent */ public function getInstanceFromRow($row) { $em = EventManager::instance(); $sysevent = null; $klass = null; $klass_params = null; switch ($row['type']) { case SystemEvent::TYPE_SYSTEM_CHECK: case SystemEvent::TYPE_EDIT_SSH_KEYS: case SystemEvent::TYPE_PROJECT_CREATE: case SystemEvent::TYPE_PROJECT_DELETE: case SystemEvent::TYPE_PROJECT_RENAME: case SystemEvent::TYPE_MEMBERSHIP_CREATE: case SystemEvent::TYPE_MEMBERSHIP_DELETE: case SystemEvent::TYPE_UGROUP_MODIFY: case SystemEvent::TYPE_USER_CREATE: case SystemEvent::TYPE_USER_DELETE: case SystemEvent::TYPE_USER_EMAIL_CHANGED: case SystemEvent::TYPE_USER_RENAME: case SystemEvent::TYPE_MAILING_LIST_CREATE: case SystemEvent::TYPE_MAILING_LIST_DELETE: case SystemEvent::TYPE_CVS_IS_PRIVATE: case SystemEvent::TYPE_PROJECT_IS_PRIVATE: case SystemEvent::TYPE_SERVICE_USAGE_SWITCH: case SystemEvent::TYPE_ROOT_DAILY: case SystemEvent::TYPE_COMPUTE_MD5SUM: $klass = 'SystemEvent_' . $row['type']; break; case SystemEvent::TYPE_SVN_UPDATE_HOOKS: $klass = 'SystemEvent_' . $row['type']; $klass_params = array(Backend::instance(Backend::SVN)); break; default: $em->processEvent(Event::GET_SYSTEM_EVENT_CLASS, array('type' => $row['type'], 'class' => &$klass, 'dependencies' => &$klass_params)); break; } $sysevent = $this->instanciateSystemEventByType($row['id'], class_exists($klass) ? $klass : $row['type'], $row['owner'], $row['parameters'], $row['priority'], $row['status'], $row['create_date'], $row['process_date'], $row['end_date'], $row['log']); if ($sysevent && !empty($klass_params)) { call_user_func_array(array($sysevent, 'injectDependencies'), $klass_params); } return $sysevent; }
public static function isNameAvailable($newName, &$error) { $b1 = new Git_Backend_Gitolite(new Git_GitoliteDriver()); $b2 = Backend::instance('Git', 'GitBackend'); if (!$b1->isNameAvailable($newName) && !$b2->isNameAvailable($newName)) { $error = $GLOBALS['Language']->getText('plugin_git', 'actions_name_not_available'); return false; } return true; }
private function getProftpdSystemEventManager() { return new \Tuleap\ProFTPd\SystemEventManager(SystemEventManager::instance(), Backend::instance(), $this->getPermissionsManager(), ProjectManager::instance(), $this->getPluginInfo()->getPropVal('proftpd_base_directory')); }
public function updateMainConfIncludes($project) { if (is_file($this->confFilePath)) { $conf = file_get_contents($this->confFilePath); } else { $conf = ''; } if (strpos($conf, 'include "projects/' . $project->getUnixName() . '.conf"') === false) { $backend = Backend::instance(); if ($conf) { $backend->removeBlock($this->confFilePath); } $newConf = ''; $dir = new DirectoryIterator('conf/projects'); foreach ($dir as $file) { if (!$file->isDot()) { $newConf .= 'include "projects/' . basename($file->getFilename()) . '"' . PHP_EOL; } } if ($backend->addBlock($this->confFilePath, $newConf)) { return $this->gitAdd($this->confFilePath); } return false; } return true; }
EventManager::instance()->processEvent(Event::SYSTEM_EVENT_GET_CUSTOM_QUEUES, array('queues' => &$custom_queues)); if (isset($custom_queues[$request_queue])) { $logger = $custom_queues[$request_queue]->getLogger(); $logger->debug('Processing ' . $request_queue . ' queue.'); $process = new SystemEventProcessCustomQueue($request_queue); $owner = $custom_queues[$request_queue]->getOwner(); } else { switch ($request_queue) { case SystemEvent::OWNER_APP: $logger->debug('Processing default queue as app user.'); $process = new SystemEventProcessApplicationOwnerDefaultQueue(); break; case SystemEvent::DEFAULT_QUEUE: $logger->debug('Processing default queue as root user.'); $owner = SystemEvent::OWNER_ROOT; $process = new SystemEventProcessRootDefaultQueue(); break; default: $logger->debug('Ignoring ' . $request_queue . ' queue.'); exit(0); } } if ($owner === SystemEvent::OWNER_APP) { require_once 'common/system_event/SystemEventProcessor_ApplicationOwner.class.php'; $processor = new SystemEventProcessor_ApplicationOwner($process, $system_event_manager, new SystemEventDao(), $logger); } else { require_once 'common/system_event/SystemEventProcessor_Root.class.php'; $processor = new SystemEventProcessor_Root($process, $system_event_manager, new SystemEventDao(), $logger, Backend::instance('Aliases'), Backend::instance('CVS'), Backend::instance('SVN'), Backend::instance('System'), new SiteCache($logger)); } $mutex = new SystemEventProcessorMutex(new SystemEventProcessManager(), $processor); $mutex->execute();
public function get_system_event_class($params) { switch ($params['type']) { case 'PLUGIN_LDAP_UPDATE_LOGIN': include_once dirname(__FILE__) . '/system_event/SystemEvent_PLUGIN_LDAP_UPDATE_LOGIN.class.php'; $params['class'] = 'SystemEvent_PLUGIN_LDAP_UPDATE_LOGIN'; $params['dependencies'] = array(UserManager::instance(), Backend::instance(Backend::SVN), ProjectManager::instance(), new LDAP_ProjectManager()); break; } }
public function removeTemporaryDirectory() { $backend = Backend::instance('System'); if (is_dir($this->dir)) { $backend->recurseDeleteInDir($this->dir); rmdir($this->dir); } }
/** * Display git backend statistics in CSV format * * @param Array $params parameters of the event * * @return void */ public function statistics_collector($params) { if (!empty($params['formatter'])) { include_once 'GitBackend.class.php'; $formatter = $params['formatter']; $gitBackend = Backend::instance('Git', 'GitBackend'); echo $gitBackend->getBackendStatistics($formatter); } }
/** * Display git backend statistics in CSV format * * @param Array $params parameters of the event * * @return void */ public function statistics_collector($params) { if (!empty($params['formatter'])) { include_once 'GitBackend.class.php'; $formatter = $params['formatter']; $gitBackend = Backend::instance('Git', 'GitBackend', array($this->getGitRepositoryUrlManager())); echo $gitBackend->getBackendStatistics($formatter); } }