Logout from the IMAP server (see RFC 3501 [6.1.3]).
433002
public function logout()
    {
        if ($this->_isAuthenticated && $this->_connection->connected) {
            $this->_logout();
            $this->_connection->close();
        }

        $this->_connection = $this->_selected = null;
        $this->_isAuthenticated = false;
        $this->_mode = 0;
    }
1020141
public function logout()
    {
        $this->execute($this->httpClient->setEndPoint(self::ENDPOINT.'logout/'));

        self::$appKey = null;
        self::$sessionToken = null;
        self::$lastLogin = null;
    }
760593
def logout_handler(self, **args):
        
        response = make_response(
            "<html><script>window.close();</script></html>", 200,
            {'Content-Type': "text/html"})
        response.set_cookie(self.account_cookie_name, expires=0)
        response.set_cookie(self.access_cookie_name, expires=0)
        response.headers['Access-Control-Allow-Origin'] = '*'
        return response
832480
def logout(database)
      command = Protocol::Command.new(database, logout: 1)
      self.write([command])
      reply = self.receive_replies([command]).first
      if command.failure?(reply)
        return
      end
      credentials.delete(database)
    end
1209285
def logout(self):
        

        self.revoke_refresh_token()
        self.revoke_access_token()

        self._username, self._password = None, None
1179030
public function disconnect()
    {
        if ( $this->state !== self::STATE_NOT_CONNECTED
             && $this->connection->isConnected() === true )
        {
            $tag = $this->getNextTag();
            $this->connection->sendData( "{$tag} LOGOUT" );
            // discard the "bye bye" message ("{$tag} OK Logout completed.")
            $this->getResponse( $tag );
            $this->state = self::STATE_LOGOUT;
            $this->selectedMailbox = null;

            $this->connection->close();
            $this->connection = null;
            $this->state = self::STATE_NOT_CONNECTED;
        }
    }
1322803
def logout(ctx):
    
    check_for_cloud_server()
    check_for_cloud_user()
    if config["cloud_server"]["farm_name"]:
        ctx.invoke(deinit_farm)
    config["cloud_server"]["username"] = None
    config["cloud_server"]["password"] = None
75879
public function logout() {
		// clear session
		foreach ( $_SESSION as $key => $value ) {
			unset( $_SESSION[$key] );
		}

		// delete the session cookie on the client
		if ( ini_get( 'session.use_cookies' ) ) {
			$params = session_get_cookie_params();
			setcookie( session_name(), '', time() - 42000,
				$params['path'], $params['domain'],
				$params['secure'], $params['httponly']
			);
		}

		// destroy local session storage
		session_destroy();
		// generate new session id
		session_regenerate_id( true );
	}
792551
public function logout() {
		$allConfiguration = $this->configurationManager->getConfiguration(\TYPO3\Flow\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'TYPO3.Flow');
		$tokens = $this->securityContext->getAuthenticationTokensOfType('Flowpack\SingleSignOn\Client\Security\SingleSignOnToken');
		foreach ($tokens as $token) {
			$providerName = $token->getAuthenticationProviderName();
			$serverIdentifier = \TYPO3\Flow\Utility\Arrays::getValueByPath($allConfiguration, 'security.authentication.providers.' . $providerName . '.providerOptions.server');
			if ($serverIdentifier !== NULL) {
				$ssoClient = $this->ssoClientFactory->create();
				$ssoServer = $this->ssoServerFactory->create($serverIdentifier);
				$ssoServer->destroySession($ssoClient, $token->getGlobalSessionId());
			}
		}
	}
629331
def logout(self):
        """"""
        self._master_token = None
        self._auth_token = None
        self._email = None
        self._android_id = None
881762
function ImapSimple(imap) {
    var self = this;
    self.imap = imap;

    // flag to determine whether we should suppress ECONNRESET from bubbling up to listener
    self.ending = false;

    // pass most node-imap `Connection` events through 1:1
    ['alert', 'mail', 'expunge', 'uidvalidity', 'update', 'close', 'end'].forEach(function (event) {
        self.imap.on(event, self.emit.bind(self, event));
    });

    // special handling for `error` event
    self.imap.on('error', function (err) {
        // if .end() has been called and an 'ECONNRESET' error is received, don't bubble
        if (err && self.ending && (err.code.toUpperCase() === 'ECONNRESET')) {
            return;
        }

        self.emit('error', err);
    });
}
1204836
def _logout(self):
        """"""

        if self.auth:
            logger.debug("ZabbixAPI.logout()")

            if self.user.logout():
                self.auth = None
1147655
def _logoutclient(self, useruuid, clientuuid):
        """"""

        self.log("Cleaning up client of logged in user.", lvl=debug)
        try:
            self._users[useruuid].clients.remove(clientuuid)
            if len(self._users[useruuid].clients) == 0:
                self.log("Last client of user disconnected.", lvl=verbose)

                self.fireEvent(userlogout(useruuid, clientuuid))
                del self._users[useruuid]

            self._clients[clientuuid].useruuid = None
        except Exception as e:
            self.log("Error during client logout: ", e, type(e),
                     clientuuid, useruuid, lvl=error,
                     exc=True)
182111
async def logout(self, request):
        
        if "Authorization" not in request.headers:
            msg = "Auth header is not present, can not destroy token"
            raise JsonValidaitonError(msg)

        response = json_response()
        await forget(request, response)

        return response
991440
def logout(self):
        
        self.client.global_sign_out(
            AccessToken=self.access_token
        )

        self.id_token = None
        self.refresh_token = None
        self.access_token = None
        self.token_type = None
105981
protected function quit()
        {
            // although RFC says QUIT can be issued at any time, we won't
            if ($this->state['helo']) {
                // [TODO] might need a try/catch here to cover some edge cases...
                $this->send('QUIT');
                $this->expect(self::SMTP_QUIT_SUCCESS, $this->command_timeouts['quit']);
            }
        }
228125
def logout(self):
        """"""
        if self._logged_in is True:
            self.si.flush_cache()
            self.sc.sessionManager.Logout()
            self._logged_in = False