Method to reinitialise the server, ie. need to login again

NOTE: This command not available on all servers

@return  boolean  True if successful

@since   1.0
@throws  FilesystemException
194712
public function reinit()
	{
		// If native FTP support is enabled let's use it...
		if (FTP_NATIVE)
		{
			if (@ftp_site($this->conn, 'REIN') === false)
			{
				throw new FilesystemException(__METHOD__ . 'Bad response.');
			}

			return true;
		}

		// Send reinitialise command to the server
		if (!$this->_putCmd('REIN', 220))
		{
			throw new FilesystemException(sprintf('%1$s: Bad response.  Server response: %2$s [Expected: 220]', __METHOD__, $this->response));
		}

		return true;
	}
1164663
public function restart()
    {
        $this->destroy();

        if ($this->state !== static::STATE_DESTROYED) {
            throw new \RuntimeException('Session not destroyed, cannot restart.');
        }

        $result = $this->doStart();

        $this->regenerate(true);

        return $result;
    }
577451
public function restart()
	{
		$this->destroy();

		if ($this->getState() !== 'destroyed')
		{
			// @TODO :: generated error here
			return false;
		}

		// Re-register the session handler after a session has been destroyed, to avoid PHP bug
		$this->store->register();

		$this->setState('restart');

		// Regenerate session id
		session_regenerate_id(true);
		$this->_start();
		$this->setState('active');

		$this->_validate();
		$this->_setCounter();

		return true;
	}
656866
public function regenerate() {
    $response = $this->client->post(self::$path . '/' . $this->key . '/regenerate');
    $this->setData($response->json());
    return $this;
  }
339759
public static boolean reload()
    {
        String biGramDictionaryPath = HanLP.Config.BiGramDictionaryPath;
        IOUtil.deleteFile(biGramDictionaryPath + ".table" + Predefine.BIN_EXT);

        return load(biGramDictionaryPath);
    }
942791
public function resume(): bool
    {
        if ($this->values->offsetExists('principal')) {
            $this->principal = $this->values->get('principal');

            $this->logger->info(
                "Authentication resume: {user}",
                ['user' => $this->principal]
            );
            $this->publishResume($this->principal, $this->values);

            $this->values->offsetSet('lastActive', microtime(true));

            return true;
        }
        return false;
    }
1293270
public function persist()
    {

        $this->ensureRootDirectory();

        $someoneSaved = false;
        foreach ($this->storages as $url=>$storage) {
            $this->ensureStorageDirectory($url);
            if ($storage->persist()) {
                $someoneSaved = true;
            }
        }

        foreach ($this->purgeQueue as $url) {
            $storage = $this->getOrCreateStorage($url);
            if ($storage->purge()) {
                $someoneSaved = true;
            }
            $this->removeStorageIfLoaded($url);
        }

        $this->purgeQueue = [];

        return $someoneSaved;
    }
229801
public function restart()
	{
		$this->destroy();

		if ($this->state !== 'destroyed')
		{
			// @TODO :: generated error here
			return false;
		}

		// Re-register the session handler after a session has been destroyed, to avoid PHP bug
		$this->store->register();

		$this->state = 'restart';

		// Regenerate session id
		session_regenerate_id(true);
		$this->_start();
		$this->state = 'active';

		$this->_validate();
		$this->_setCounter();

		return true;
	}
942639
public function setUpMode()
    {
        $file = $this->maintenanceFilePath();

        if (file_exists($file) && !unlink($file)) {
            $message = sprintf(
                'Something went wrong on trying to remove maintenance file %s.',
                $file
            );

            throw new Exceptions\FileException($message);
        }

        return true;
    }
544250
protected function resetMain()
    {
        try {
            $language = $this->languageRepository->mainLanguage();
            if (null !== $language) {
                $result = $this->languageRepository
                            ->setRepositoryObject($language)
                            ->save(array('MainLanguage' => 0));

                return $result;
            }

            return true;
        } catch (\Exception $e) {
            if (isset($this->languageRepository) && $this->languageRepository !== null) {
                $this->languageRepository->rollBack();
            }

            throw $e;
        }
    }
489636
public boolean reboot() {
        if (!sendCommand("reboot")) {
            return false;
        }

        // wait 1 second
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
        }

        disconnect();

        // check that remote host is not accessible anymore
        // open a socket without any parameters. It hasn't been binded or connected
        try (Socket socket = new Socket()) {
            // bind to a local ephemeral port
            socket.bind(null);
            socket.connect(new InetSocketAddress(remoteHost, RLoginClient.DEFAULT_PORT), 1);
        } catch (SocketTimeoutException e) {
            logger.info("Rebooted host " + remoteHost + " successfully");
            return true;
        } catch (IOException e) {
            logger.error("Something went wrong while rebooting host:" + remoteHost);
            return false;
        }
        // Expected to get an exception as the remote host should not be reachable anymore
        logger.error(
              "Host " + remoteHost + " did not reboot as expected! Please check that no other rlogin client is connected!");
        return false;
    }
25830
public function init() {
        // Do not cache CMS pages. This prevents a common situation where people logout, return to
        // the CMS, and see the interface but none of the content feeds load. Only after a browser
        // refresh they'll get bounced to the login page.
        $this->_helper->cache->setNoCacheHeaders($this->getResponse());

        $config = Zend_Registry::get('config');
        $this->_setCmsClosedMessage();
        if (!$config->cms || !$config->cms->ipfilter || !count($config->cms->ipfilter->toArray())) {
            return true;
        }
        $ip = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : null;
        if ($ip === '127.0.0.1') {
            // i mean come on
            return true;
        }
        if (!in_array($ip, $config->cms->ipfilter->toArray())) {
            $authVars = Garp_Auth::getInstance()->getConfigValues();
            $this->_helper->flashMessenger(__($authVars['noPermissionMsg']));
            $this->_helper->redirector->gotoRoute(array(), $authVars['login']['route']);
            return false;
        }
    }
1092774
public function reset(){
        if($this->status() !== self::ACTIVE){
            throw Exception\SessionException::notStarted();
        }

        session_reset();

        return $this;
    }
74357
public function restartCommand(): void
    {
        $daemon = $this->input->getSameOpt(['d', 'daemon']);

        $this->createServer()->asDaemon($daemon)->restart();
    }
1351221
public function reset()
    {
        $this->domain   = null;
        $this->fragment = null;
        $this->hostname = null;
        $this->ipv4     = null;
        $this->ipv6     = null;
        $this->password = null;
        $this->path     = null;
        $this->port     = null;
        $this->query    = null;
        $this->scheme   = null;
        $this->tld      = null;
        $this->url      = null;
        $this->username = null;

        return $this;
    }
503550
public function Restart() {
      $this->Permission('Garden.Import'); // This permission doesn't exist, so only users with Admin == '1' will succeed.

      // Delete the individual table files.
      $Imp = new ImportModel();
      try {
         $Imp->LoadState();
         $Imp->DeleteFiles();
      } catch(Exception $Ex) {
      }
      $Imp->DeleteState();

      Redirect(strtolower($this->Application).'/import');
   }
224763
public function reconnect()
    {
        if ($this->getMaxReconnects() < $this->getReconnectCount()) {
            return false;
        }

        $this->increaseReconnectCount();
        // returns the state if the ping was possible
        return $this->ping();
    }