Simple handler for logout
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
60714
protected void logOut(O out) {
        String s = "";
        if (out != null) {
            s = outToString(out);
        }
        if (LOG.isTraceEnabled()) {
            LOG.trace("Process result: " + s);
        } else if (LOG.isDebugEnabled()) {
            if (s.length() > 4000)
                s = s.substring(0, 4000) + "...";
            LOG.debug("Process result: " + s);
        }
    }
1328017
def logout(self):
        
        resp = super(CookieSession, self).request('DELETE', self._session_url)
        resp.raise_for_status()
820564
public function logout()
    {
        $user = $this->sentry->getUser();
        $this->sentry->logout();
        $this->event->fire('users.logout',array($user));
    }
1199589
function logout() {
    currentUser = null;
    delete config.usr;
    delete config.pwd;
    Storage.local.set( "nigolotua", null );
    exports.eventChange.fire();
    return svc( "tfw.login.Logout" );
}
738899
function logOutput(options, parts) {
  const msg = `${ 'Generated '.blue }${ path.resolve.apply(path, parts).cyan }`
  log(options, msg)
}
1131316
public function logout()
    {
        Piwik::postEvent('Login.logout', array(Piwik::getCurrentUserLogin()));

        self::clearSession();

        $logoutUrl = @Config::getInstance()->General['login_logout_url'];
        if (empty($logoutUrl)) {
            Piwik::redirectToModule('CoreHome');
        } else {
            Url::redirectToUrl($logoutUrl);
        }
    }
190074
public function logout()
    {
        // Token from Clef.io
        if (isset($_POST['logout_token'])) {
            // Verif token
            $clef = \Aperdia\Clef::logout($_POST['logout_token']);

            if (!$clef) {
                // Verif in Authentication table
                $auth = Authentication::whereprovider("clef")->whereprovider_uid($clef)->first();

                if (!empty($auth)) {
                    $user = User::find($auth->user_id);

                    if (!empty($user)) {
                        $user->logout = 1;
                        $user->save();
                    }
                }
            }
        }
    }
325672
def logout(self, api_version="v2.0"):
        

        cur_ctlr = self._parent_class.controller

        url = str(cur_ctlr) + "/{}/api/logout".format(api_version)

        api_logger.debug("URL = %s", url)
        return self._parent_class.rest_call(url, "get")
103437
function logout() {
    if (exports.currentLogin === null) {
        log_1.logger.debug(`[API] Already logged out`);
        return Promise.resolve();
    }
    log_1.logger.info(`[API] Logging out ${exports.currentLogin.username}`);
    return get('logout', null, true).then(() => {
        clearHeaders();
        exports.currentLogin = null;
    });
}
940720
def main(options):
    """"""
        
    client = Client(server=options.server, username=options.username, password=options.password)
    print('Successfully connected to %s' % client.server)
    print(client.si.CurrentTime())
    
    client.logout()
612002
public function logout()
	{
		$user = $this->user();

		// If we have an event dispatcher instance, we can fire off the logout event
		// so any further processing can be done. This allows the developer to be
		// listening for anytime a user signs out of this application manually.
		$this->clearUserDataFromStorage();

		if ( ! is_null($this->user))
		{
			$this->refreshRememberToken($user);
		}

		if (isset($this->events))
		{
			$this->events->fire('auth.logout', [$user]);
		}

		// Once we have fired the logout event we will clear the users out of memory
		// so they are no longer available as the user is no longer considered as
		// being signed into this application and should not be available here.
		$this->user = null;

		$this->loggedOut = true;
	}
378010
function logoutpage_hook() {
        global $SESSION, $redirect;

        // Only do this if logout handler is defined, and if the user is actually logged in via Shibboleth
        $logouthandlervalid = isset($this->config->logout_handler) && !empty($this->config->logout_handler);
        if (isset($SESSION->shibboleth_session_id) && $logouthandlervalid ) {
            // Check if there is an alternative logout return url defined
            if (isset($this->config->logout_return_url) && !empty($this->config->logout_return_url)) {
                // Set temp_redirect to alternative return url
                $temp_redirect = $this->config->logout_return_url;
            } else {
                // Backup old redirect url
                $temp_redirect = $redirect;
            }

            // Overwrite redirect in order to send user to Shibboleth logout page and let him return back
            $redirecturl = new moodle_url($this->config->logout_handler, array('return' => $temp_redirect));
            $redirect = $redirecturl->out();
        }
    }
445939
def logout_user():
    '''
    
    '''

    user = _get_user()

    if 'user_id' in session:
        session.pop('user_id')

    if '_fresh' in session:
        session.pop('_fresh')

    if '_id' in session:
        session.pop('_id')

    cookie_name = current_app.config.get('REMEMBER_COOKIE_NAME', COOKIE_NAME)
    if cookie_name in request.cookies:
        session['remember'] = 'clear'
        if 'remember_seconds' in session:
            session.pop('remember_seconds')

    user_logged_out.send(current_app._get_current_object(), user=user)

    current_app.login_manager._update_request_context_with_user()
    return True
243177
function logout(options) {
  return async function logoutHandler(ctx) {
    let referer = formatReferer(ctx, options.logoutPath, options.rootPath);
    const user = ctx.session[options.userField];
    if (!user) {
      return redirect(ctx, referer);
    }

    const redirectURL = await options.logoutCallback(ctx, user);

    ctx.session[options.userField] = null;
    if (redirectURL) {
      referer = redirectURL;
    }
    redirect(ctx, referer);
  };
}
905212
def __Logout(si):
   
   try:
      if si:
         content = si.RetrieveContent()
         content.sessionManager.Logout()
   except Exception as e:
      pass
203591
public void logout(final BooleanCallback callback) {
		GwtCommand command = new GwtCommand(logoutCommandName);
		GwtCommandDispatcher.getInstance().execute(command, new AbstractCommandCallback<SuccessCommandResponse>() {

			public void execute(SuccessCommandResponse response) {
				if (response.isSuccess()) {
					userToken = null;
					Authentication.this.userId = null;
					if (callback != null) {
						callback.execute(true);
					}
					GwtCommandDispatcher.getInstance().logout();
					manager.fireEvent(new LogoutSuccessEvent());
				} else {
					if (callback != null) {
						callback.execute(false);
					}
					manager.fireEvent(new LogoutFailureEvent());
				}
			}
		});
	}