public function execute() {
$userName = '******'; // <- targer username
$user = new CentralAuthUser( $userName );
if ( !$user->exists() ) {
echo "Cannot unsuppress non-existent user {$userName}!\n";
exit( 0 );
}
$userName = $user->getName(); // sanity
$wikis = $user->listAttached(); // wikis with attached accounts
foreach ( $wikis as $wiki ) {
$lb = wfGetLB( $wiki );
$dbw = $lb->getConnection( DB_MASTER, array(), $wiki );
# Get local ID like $user->localUserData( $wiki ) does
$localUserId = $dbw->selectField( 'user', 'user_id',
array( 'user_name' => $userName ), __METHOD__ );
$delUserBit = Revision::DELETED_USER;
$hiddenCount = $dbw->selectField( 'revision', 'COUNT(*)',
array( 'rev_user' => $localUserId, "rev_deleted & $delUserBit != 0" ), __METHOD__ );
echo "$hiddenCount edits have the username hidden on \"$wiki\"\n";
# Unsuppress username on edits
if ( $hiddenCount > 0 ) {
echo "Unsuppressed edits of attached account (local id $localUserId) on \"$wiki\"...";
IPBlockForm::unsuppressUserName( $userName, $localUserId, $dbw );
echo "done!\n\n";
}
$lb->reuseConnection( $dbw ); // not really needed
# Don't lag too bad
wfWaitForSlaves( 5 );
}
}
protected function done()
{
parent::done();
foreach ($this->params['from'] as $from) {
$caOld = new CentralAuthUser($from);
$caOld->quickInvalidateCache();
}
}
private function updateUser($username)
{
$user = new CentralAuthUser($username);
$this->output('Resetting user_token for "' . $username . '": ');
// Change value
$user->resetAuthToken();
$this->output(" OK\n");
}
function execute($par)
{
global $wgMemc;
$tempToken = $this->getRequest()->getVal('token');
$logout = $this->getRequest()->getBool('logout');
# Don't cache error messages
$this->getOutput()->enableClientCache(false);
if (strlen($tempToken) == 0) {
$this->setHeaders();
$this->getOutput()->addWikiMsg('centralauth-autologin-desc');
return;
}
$key = CentralAuthUser::memcKey('login-token', $tempToken);
$data = $wgMemc->get($key);
$wgMemc->delete($key);
if (!$data) {
$msg = 'Token is invalid or has expired';
wfDebug(__METHOD__ . ": {$msg}\n");
$this->setHeaders();
$this->getOutput()->addWikiText($msg);
return;
}
$userName = $data['userName'];
$token = $data['token'];
$remember = $data['remember'];
if ($data['wiki'] != wfWikiID()) {
$msg = 'Bad token (wrong wiki)';
wfDebug(__METHOD__ . ": {$msg}\n");
$this->setHeaders();
$this->getOutput()->addWikiText($msg);
return;
}
$centralUser = new CentralAuthUser($userName);
$loginResult = $centralUser->authenticateWithToken($token);
if ($loginResult != 'ok') {
$msg = "Bad token: {$loginResult}";
wfDebug(__METHOD__ . ": {$msg}\n");
$this->setHeaders();
$this->getOutput()->addWikiText($msg);
return;
}
// Auth OK.
if ($logout) {
$centralUser->deleteGlobalCookies();
} else {
$centralUser->setGlobalCookies($remember);
}
$this->getOutput()->disable();
wfResetOutputBuffers();
header('Cache-Control: no-cache');
header('Content-Type: image/png');
global $wgCentralAuthLoginIcon;
if ($wgCentralAuthLoginIcon) {
readfile($wgCentralAuthLoginIcon);
} else {
readfile(dirname(__FILE__) . '/1x1.png');
}
}
public function execute()
{
$params = $this->extractRequestParams();
$prop = array_flip((array) $params['prop']);
$from = isset($params['from']) ? $params['from'] : null;
$APIResult = $this->getResult();
$data = array();
/**
* @var $wikiSet WikiSet
*/
foreach (WikiSet::getAllWikiSets($from, $params['limit'], $params['orderbyname']) as $wikiSet) {
$entry = array();
$entry['id'] = $wikiSet->getId();
$entry['name'] = $wikiSet->getName();
if (isset($prop['type'])) {
$entry['type'] = $wikiSet->getType();
}
if (isset($prop['wikisincluded'])) {
$entry['wikisincluded'] = $wikiSet->getWikis();
if (count($entry['wikisincluded'])) {
$APIResult->setIndexedTagName($entry['wikisincluded'], 'wiki');
}
}
if (isset($prop['wikisnotincluded'])) {
$entry['wikisnotincluded'] = array_diff(CentralAuthUser::getWikiList(), $wikiSet->getWikis());
if (count($entry['wikisnotincluded'])) {
$APIResult->setIndexedTagName($entry['wikisnotincluded'], 'wiki');
}
}
$data[] = $entry;
}
$APIResult->setIndexedTagName($data, 'wikiset');
$APIResult->addValue('query', $this->getModuleName(), $data);
}
/**
* Try to create and attach the user.
* @throws Exception
* @return bool Success
*/
public function run()
{
$username = $this->params['name'];
$from = $this->params['from'];
$wiki = wfWikiID();
if (isset($this->params['session'])) {
// restore IP and other request data
$this->params['session']['userId'] = 0;
$this->params['session']['sessionId'] = '';
$callback = RequestContext::importScopedSession($this->params['session']);
}
$user = User::newFromName($username);
$centralUser = CentralAuthUser::getInstance($user);
if ($user->getId() !== 0) {
wfDebugLog('CentralAuth', __CLASS__ . ": tried to create local account for {$username} " . "on {$wiki} from {$from} but one already exists\n");
return true;
} elseif (!$centralUser->exists()) {
wfDebugLog('CentralAuth', __CLASS__ . ": tried to create local account for {$username} " . "on {$wiki} from {$from} but no global account exists\n");
return true;
} elseif ($centralUser->attachedOn($wiki)) {
wfDebugLog('CentralAuth', __CLASS__ . ": tried to create local account for {$username} " . "on {$wiki} from {$from} but an attached local account already exists\n");
return true;
}
$success = CentralAuthHooks::attemptAddUser($user);
if ($success) {
$centralUser->invalidateCache();
}
return true;
}
/**
* Check that we can perform the rename
*
* @param User $oldUser
* @param User $newUser
*
* @return Status
*/
public function validate(User $oldUser, User $newUser)
{
$status = new Status();
if (!User::isCreatableName($newUser->getName())) {
$status->fatal('centralauth-rename-badusername');
}
$caOldUser = CentralAuthUser::getInstance($oldUser);
if (!$caOldUser->exists()) {
$status->fatal('centralauth-rename-doesnotexist');
}
$caNewUser = CentralAuthUser::getInstance($newUser);
if ($caNewUser->exists()) {
$status->fatal('centralauth-rename-alreadyexists');
}
$unattached = $caNewUser->listUnattached();
if ($unattached) {
$status->fatal('centralauth-rename-unattached-intheway');
}
// Check we're not currently renaming the user
$renameState = $caOldUser->renameInProgress();
if ($renameState) {
$status->fatal('centralauth-rename-alreadyinprogress', $renameState[1]);
}
return $status;
}
public function execute()
{
$user = $this->getUser();
$params = $this->extractRequestParams();
// If we're in JSON callback mode, no tokens can be obtained
if ($this->lacksSameOriginSecurity()) {
$this->dieUsage('Cannot obtain a centralauthtoken when using a callback', 'hascallback');
}
if ($user->isAnon()) {
$this->dieUsage('Anonymous users cannot obtain a centralauthtoken', 'notloggedin');
}
if (CentralAuthHooks::hasApiToken()) {
$this->dieUsage('Cannot obtain a centralauthtoken when using centralauthtoken', 'norecursion');
}
$centralUser = CentralAuthUser::getInstance($user);
if (!$centralUser->exists() || !$centralUser->isAttached()) {
$this->dieUsage('Cannot obtain a centralauthtoken without an attached global account', 'notattached');
}
$data = array('userName' => $user->getName(), 'token' => $centralUser->getAuthToken());
global $wgMemc;
$loginToken = MWCryptRand::generateHex(32) . dechex($centralUser->getId());
$key = CentralAuthUser::memcKey('api-token', $loginToken);
$wgMemc->add($key, $data, 60);
$this->getResult()->addValue(null, $this->getModuleName(), array('centralauthtoken' => $loginToken));
}
/**
* Copy user data for this wiki into the localuser table
*/
function migratePassZero()
{
global $wgDBname;
$dbr = wfGetDB(DB_SLAVE);
$chunkSize = 1000;
$start = microtime(true);
$migrated = 0;
$users = array();
// List all user accounts on this wiki in the migration table
// on the central authentication server.
$lastUser = $dbr->selectField('user', 'MAX(user_id)', '', __FUNCTION__);
for ($min = 0; $min <= $lastUser; $min += $chunkSize) {
$max = $min + $chunkSize - 1;
$result = $dbr->select('user', array('user_id', 'user_name'), "user_id BETWEEN {$min} AND {$max}", __FUNCTION__);
foreach ($result as $row) {
$users[intval($row->user_id)] = $row->user_name;
++$migrated;
}
CentralAuthUser::storeMigrationData($wgDBname, $users);
$users = array();
// clear the array for the next pass
$delta = microtime(true) - $start;
$rate = $delta == 0.0 ? 0.0 : $migrated / $delta;
printf("%s %d (%0.1f%%) done in %0.1f secs (%0.3f accounts/sec).\n", $wgDBname, $migrated, min($max, $lastUser) / $lastUser * 100.0, $delta, $rate);
if (($min + $chunkSize) % ($chunkSize * 10) == 0) {
echo "Waiting for slaves to catch up ... ";
CentralAuthUser::waitForSlaves();
echo "done\n";
}
}
}
public function execute()
{
$params = $this->extractRequestParams();
$prop = array_flip((array) $params['prop']);
$APIResult = $this->getResult();
$data = array();
$dbr = CentralAuthUser::getCentralSlaveDB();
$fields = array('ggp_group');
if (isset($prop['rights'])) {
$fields[] = 'ggp_permission';
}
$result = $dbr->select('global_group_permissions', $fields, array(), __METHOD__, array('DISTINCT'));
$globalGroups = array();
foreach ($result as $row) {
if (!isset($globalGroups[$row->ggp_group])) {
$globalGroups[$row->ggp_group] = array('rights' => array());
}
if (isset($prop['rights'])) {
$globalGroups[$row->ggp_group]['rights'][] = $row->ggp_permission;
}
}
foreach ($globalGroups as $name => $value) {
$entry = array('name' => $name);
if (isset($prop['rights']) && count($value['rights'])) {
$entry['rights'] = $value['rights'];
$APIResult->setIndexedTagName($entry['rights'], 'right');
}
$data[] = $entry;
}
$APIResult->setIndexedTagName($data, 'globalgroup');
$APIResult->addValue('query', $this->getModuleName(), $data);
}
public function execute()
{
if (!class_exists('CentralAuthUser')) {
$this->error("CentralAuth isn't enabled on this wiki\n", 1);
}
$username = $this->getArg(0);
$user = User::newFromName($username);
if ($user === false) {
$this->error("'{$username}' is an invalid username\n", 1);
}
// Normalize username
$username = $user->getName();
if ($user->getId()) {
$this->error("User '{$username}' already exists\n", 1);
} else {
global $wgAuth;
$central = CentralAuthUser::getInstance($user);
if (!$central->exists()) {
$this->error("No such global user: '******'\n", 1);
}
$user->loadDefaults($username);
$user->addToDatabase();
$wgAuth->initUser($user, true);
$wgAuth->updateUser($user);
# Notify hooks (e.g. Newuserlog)
Hooks::run('AuthPluginAutoCreate', array($user));
# Update user count
$ssUpdate = new SiteStatsUpdate(0, 0, 0, 0, 1);
$ssUpdate->doUpdate();
$this->output("User '{$username}' created\n");
}
}
/**
* Execute the job
*
* @return bool
*/
public function run()
{
$username = $this->params['username'];
$by = $this->params['by'];
$wikis = $this->params['wikis'];
$suppress = $this->params['suppress'];
$reason = $this->params['reason'];
$user = new CentralAuthUser($username);
if (!$user->exists()) {
wfDebugLog('suppressjob', "Requested to suppress non-existent user {$username} by {$by}.");
}
foreach ($wikis as $wiki) {
$user->doLocalSuppression($suppress, $wiki, $by, $reason);
wfDebugLog('suppressjob', ($suppress ? 'S' : 'Uns') . "uppressed {$username} at {$wiki} by {$by} via job queue.");
}
return true;
}
/**
* Switches a user's preferences off
* @param $user User object to set preferences for
* @param $global bool Whether to apply this change on all wikis in $wgPrefSwitchWikis
*/
public static function switchOff($user, $global = false)
{
self::switchOffUser($user);
if ($global) {
$globalUser = new CentralAuthUser($user->getName());
if (!$globalUser->exists()) {
return;
}
$accounts = $globalUser->queryAttached();
foreach ($accounts as $account) {
$remoteUser = UserRightsProxy::newFromName($account['wiki'], $globalUser->getName(), true);
if ($remoteUser) {
self::switchOffUser($remoteUser);
}
}
}
}
/**
* Get a DatabaseBase object for the CentralAuth db
*
* @param int $type DB_SLAVE or DB_MASTER
*
* @return DatabaseBase
*/
protected function getDB($type = DB_SLAVE)
{
if ($type === DB_MASTER) {
return CentralAuthUser::getCentralDB();
} else {
return CentralAuthUser::getCentralSlaveDB();
}
}
/**
* @param $row
*/
function setCurrent($row)
{
parent::setCurrent($row);
if ($row !== false) {
$caRow = isset($this->globalData[$row->user_name]) ? $this->globalData[$row->user_name] : false;
$this->current->centralAuthObj = CentralAuthUser::newFromRow($caRow);
}
}
public function execute()
{
$centralMaster = CentralAuthUser::getCentralDB();
$centralSlave = CentralAuthUser::getCentralSlaveDB();
if ($this->getOption('delete', false) === true) {
$this->dryrun = false;
}
$wiki = $this->getOption('wiki', false);
if ($wiki !== false) {
$this->wiki = $wiki;
}
if ($this->getOption('verbose', false) !== false) {
$this->verbose = true;
}
// since the keys on localnames are not conducive to batch operations and
// because of the database shards, grab a list of the wikis and we will
// iterate from there
$wikis = array();
if (!is_null($this->wiki)) {
$wikis[] = $this->wiki;
} else {
$result = $centralSlave->select('localnames', array('ln_wiki'), "", __METHOD__, array("DISTINCT", "ORDER BY" => "ln_wiki ASC"));
foreach ($result as $row) {
$wikis[] = $row->ln_wiki;
}
}
// iterate through the wikis
foreach ($wikis as $wiki) {
$localdb = wfGetDB(DB_SLAVE, array(), $wiki);
$lastUsername = "";
$this->output("Checking localnames for {$wiki} ...\n");
// batch query localnames from the wiki
do {
$this->output("\t ... querying from '{$lastUsername}'\n");
$result = $centralSlave->select('localnames', array('ln_name'), array("ln_wiki" => $wiki, "ln_name > " . $centralSlave->addQuotes($lastUsername)), __METHOD__, array("LIMIT" => $this->batchSize, "ORDER BY" => "ln_name ASC"));
// iterate through each of the localnames to confirm that a local user
foreach ($result as $u) {
$localUser = $localdb->select('user', array('user_name'), array("user_name" => $u->ln_name), __METHOD__);
// check to see if the user did not exist in the local user table
if ($localUser->numRows() == 0) {
if ($this->verbose) {
$this->output("Local user not found for localname entry {$u->ln_name}@{$wiki}\n");
}
$this->total++;
if (!$this->dryrun) {
// go ahead and delete the extraneous entry
$deleted = $centralMaster->delete('localnames', array("ln_wiki" => $wiki, "ln_name" => $u->ln_name), __METHOD__);
// TODO: is there anyway to check the success of the delete?
$this->deleted++;
}
}
$lastUsername = $u->ln_name;
}
} while ($result->numRows() > 0);
}
$this->report();
$this->output("done.\n");
}
/**
*
*/
function showLogExtract()
{
$user = $this->mGlobalUser->getName();
$text = '';
$numRows = LogEventsList::showLogExtract($text, array('globalauth', 'suppress'), Title::newFromText("User:{$user}@global")->getPrefixedText(), '', array('showIfEmpty' => true));
if ($numRows) {
$this->getOutput()->addHTML(Xml::fieldset(wfMsg('centralauth-admin-logsnippet'), $text));
}
}
public function provideAbortLogin()
{
$user = User::newFromName('GlobalUser');
$lockedUser = User::newFromName('GlobalLockedUser');
// We can fake out CentralAuthUser::getInstance() by adding centralAuthObj
$noUser = User::newFromName('NoUser');
$noUser->centralAuthObj = CentralAuthUser::newUnattached('NoUser');
return array(array($user, true, 'Attached user can login'), array($noUser, true, 'Unattached user can login'), array($lockedUser, false, 'Locked User cannot login'));
}
public function execute()
{
$this->output("CentralAuth migration pass 1:\n");
$this->output("Finding accounts which can be migrated without interaction...\n");
$dbBackground = CentralAuthUser::getCentralSlaveDB();
$result = $dbBackground->select('globalnames', array('gn_name'), array(), __METHOD__);
foreach ($result as $row) {
$this->fromPrefix = $row->gn_name;
$central = new CentralAuthUser($row->gn_name);
if ($central->storeAndMigrate()) {
$this->migrated++;
}
if (++$this->total % 1000 == 0) {
$this->migratePassOneReport();
}
}
$this->migratePassOneReport();
$this->output("done.\n");
}
function migratePassOne()
{
$migrated = 0;
$total = 0;
$chunkSize = 1000;
$start = microtime(true);
$dbBackground = CentralAuthUser::getCentralSlaveDB();
$result = $dbBackground->select('globalnames', array('gn_name'), '', __METHOD__);
foreach ($result as $row) {
$name = $row->gn_name;
$central = new CentralAuthUser($name);
if ($central->storeAndMigrate()) {
$migrated++;
}
if (++$total % $chunkSize == 0) {
migratePassOneReport($migrated, $total, $start);
}
}
migratePassOneReport($migrated, $total, $start);
echo "DONE\n";
}
public function execute()
{
$db = CentralAuthUser::getCentralSlaveDB();
$conds = array();
$count = 0;
do {
$result = $db->select('globaluser', array('gu_name'), array_merge($conds, array('gu_home_db IS NULL OR gu_home_db = ""')), __METHOD__, array('LIMIT' => $this->mBatchSize, 'ORDER BY' => 'gu_name'));
foreach ($result as $row) {
$central = new CentralAuthUser($row->gu_name);
$central->mStateDirty = true;
$central->saveSettings();
$count++;
}
$this->output("{$count}\n");
CentralAuthUser::waitForSlaves();
if ($result->numRows() < $this->mBatchSize) {
break;
}
$conds = array('gu_name > ' . $db->addQuotes($row->gu_name));
} while (true);
$this->output("done.\n");
}
/**
* Get a GlobalUser object from a user's global id
*
* @param int $id
* @return GlobalUser
*/
public static function newFromId($id)
{
// Use CentralAuth if available. Use local user to ease testing.
if (class_exists('\\CentralAuthUser')) {
$user = \CentralAuthUser::newFromId($id);
} else {
$user = \User::newFromId($id);
}
if ($user === null) {
throw new \MWException("Unable to find global user for");
}
return new GlobalUser($user);
}
public function execute()
{
$dbw = CentralAuthUser::getCentralDB();
$databaseUpdates = new UsersToRenameDatabaseUpdates($dbw);
// CentralAuthUser::chooseHomeWiki is expensive and called
// multiple times, so lets cache it.
$cache = new MapCacheLRU($this->mBatchSize);
do {
$rows = $this->doQuery();
$insertRows = array();
foreach ($rows as $row) {
$this->lName = $row->name;
$this->lWiki = $row->wiki;
if ($cache->has($row->name)) {
$attachableWikis = $cache->get($row->name);
} else {
$ca = new CentralAuthUser($row->name);
$attachableWikis = array();
$unattached = $ca->queryUnattached();
if ($ca->exists()) {
$home = $ca->getHomeWiki();
$attachableWikis[] = $home;
foreach ($unattached as $wiki => $info) {
if ($ca->getEmailAuthenticationTimestamp() && $info['email'] === $ca->getEmail() && !is_null($info['emailAuthenticated'])) {
$attachableWikis[] = $wiki;
}
}
} else {
$home = $ca->chooseHomeWiki($unattached);
$attachableWikis[] = $home;
if ($unattached[$home]['email'] && isset($unattached[$home]['emailAuthenticated'])) {
foreach ($unattached as $wiki => $info) {
if ($wiki !== $home && $unattached[$home]['email'] === $info['email'] && isset($info['emailAuthenticated'])) {
$attachableWikis[] = $wiki;
}
}
}
}
$cache->set($row->name, $attachableWikis);
}
if (!in_array($row->wiki, $attachableWikis)) {
// Unattached account which is not attachable,
// so they're getting renamed :(
$this->output("{$row->name}@{$row->wiki} is going to be renamed.\n");
$insertRows[] = (array) $row;
}
}
$databaseUpdates->batchInsert($insertRows);
$count = $dbw->affectedRows();
$this->output("Inserted {$count} users who we will rename\n");
$this->output("Waiting for slaves...\n");
CentralAuthUser::waitForSlaves();
} while ($count !== 0);
}
private function showLogExtract()
{
$user = $this->mGlobalUser->getName();
$text = '';
$logTypes = array('globalauth');
if ($this->mCanOversight) {
$logTypes[] = 'suppress';
}
$numRows = LogEventsList::showLogExtract($text, $logTypes, Title::newFromText(MWNamespace::getCanonicalName(NS_USER) . ":{$user}@global")->getPrefixedText(), '', array('showIfEmpty' => true));
if ($numRows) {
$this->getOutput()->addHTML(Xml::fieldset($this->msg('centralauth-admin-logsnippet')->text(), $text));
}
}
/**
* Set the cookie for hiding fundraising banners.
*/
function setHideCookie()
{
global $wgNoticeCookieDomain, $wgCookieSecure, $wgNoticeHideBannersExpiration;
if (is_numeric($wgNoticeHideBannersExpiration)) {
$exp = $wgNoticeHideBannersExpiration;
} else {
$exp = time() + 86400 * 14;
// Cookie expires after 2 weeks
}
if (is_callable(array('CentralAuthUser', 'getCookieDomain'))) {
$cookieDomain = CentralAuthUser::getCookieDomain();
} else {
$cookieDomain = $wgNoticeCookieDomain;
}
// Hide fundraising banners for this domain
setcookie('centralnotice_fundraising', 'hide', $exp, '/', $cookieDomain, $wgCookieSecure);
}
/**
* @param $row
*/
function setCurrent($row)
{
parent::setCurrent($row);
if ($row !== false) {
if (isset($this->globalData[$row->user_name])) {
$caRow = $this->globalData[$row->user_name];
// Like taken from GlobalRenameUserStatus::getNames
$renameUser = array();
if ($caRow->ru_oldname) {
$renameUser = array($caRow->ru_oldname, $caRow->ru_newname);
}
$this->current->centralAuthObj = CentralAuthUser::newFromRow($caRow, $renameUser);
} else {
$this->current->centralAuthObj = CentralAuthUser::newUnattached($row->user_name);
}
}
}
function execute()
{
$wikis = file('/srv/mediawiki/dblist/deleted.dblist');
if ($wikis === false) {
$this->error('Unable to open deleted.dblist', 1);
}
$dbw = $this->getDB(DB_MASTER);
$cadbw = CentralAuthUser::getCentralDB();
foreach ($wikis as $wiki) {
$wiki = rtrim($wiki);
$this->output("{$wiki}:\n");
$this->doDeletes($cadbw, 'localnames', 'ln_wiki', $wiki);
$this->doDeletes($cadbw, 'localuser', 'lu_wiki', $wiki);
// @todo: Delete from wikisets
}
$this->output("Done.\n");
}
public function execute()
{
$dbw = CentralAuthUser::getCentralDB();
$dbr = CentralAuthUser::getCentralSlaveDB();
$total = 0;
do {
$rows = $dbr->select(array('users_to_rename', 'localuser'), array('utr_id', 'utr_name', 'utr_wiki'), array(), __METHOD__, array('LIMIT' => $this->mBatchSize), array('localuser' => array('INNER JOIN', 'utr_wiki=lu_wiki AND utr_name=lu_name')));
$ids = array();
foreach ($rows as $row) {
$ids[] = $row->utr_id;
$this->output("{$row->utr_name}@{$row->utr_wiki} is now attached!\n");
}
if ($ids) {
$count = count($ids);
$this->output("Deleting {$count} users...\n");
$dbw->delete('users_to_rename', array('utr_id' => $ids), __METHOD__);
$total += $count;
}
CentralAuthUser::waitForSlaves();
} while ($rows->numRows() >= $this->mBatchSize);
$this->output("Removed {$total} users in total.\n");
}
/**
* Rename a global user (this assumes that the data has been verified before
* and that $newUser is being a creatable user)!
*
* @param $options array
* @return Status
*/
public function rename(array $options)
{
$wikis = $this->oldCAUser->listAttached();
$status = $this->setRenameStatuses($wikis);
if (!$status->isOK()) {
return $status;
}
$this->databaseUpdates->update($this->oldUser->getName(), $this->newUser->getName());
// Update CA's AntiSpoof if enabled
if (class_exists('CentralAuthSpoofUser')) {
$spoof = new CentralAuthSpoofUser($this->newUser->getName());
$spoof->update($this->oldUser->getName());
}
// From this point on all code using CentralAuthUser
// needs to use the new username, except for
// the renameInProgress function. Probably.
// Clear some caches...
$this->oldCAUser->quickInvalidateCache();
$this->newCAUser->quickInvalidateCache();
$this->injectLocalRenameUserJobs($wikis, $options);
$this->logger->log($this->oldUser->getName(), $this->newUser->getName(), $options['reason']);
return Status::newGood();
}
public function execute()
{
if (!$this->getUser()->isAllowed('centralauth-unmerge')) {
$this->dieUsageMsg(array('badaccess-groups'));
}
$params = $this->extractRequestParams();
$globalUser = new CentralAuthUser($params['user']);
if (!$globalUser->exists()) {
$this->dieUsageMsg(array('nosuchuser', $globalUser->getName()));
} elseif ($globalUser->isOversighted() && !$this->getUser()->isAllowed('centralauth-oversight')) {
$this->dieUsageMsg(array('nosuchuser', $globalUser->getName()));
}
$status = $globalUser->adminDelete($params['reason']);
if ($status->isGood()) {
$this->getResult()->addValue(null, $this->getModuleName(), array('user' => $globalUser->getName(), 'reason' => $params['reason']));
} else {
if (is_callable(array($this, 'getErrorFormatter'))) {
$error = $this->getErrorFormatter()->arrayFromStatus($status);
} else {
$error = $this->getResult()->convertStatusToArray($status);
}
$this->getResult()->addValue('error', null, $error);
}
}
