End a single sign-on session for the current user.
497610
def logout_user(request):
    """"""
    logger.debug("Logout request received for %s" % request.user)
    if is_authenticated(request.user):
        ServiceTicket.objects.consume_tickets(request.user)
        ProxyTicket.objects.consume_tickets(request.user)
        ProxyGrantingTicket.objects.consume_tickets(request.user)

        ServiceTicket.objects.request_sign_out(request.user)

        logger.info("Single sign-on session ended for %s" % request.user)
        logout(request)
        messages.success(request, _('You have been successfully logged out'))
310415
def logout(self):
        
        self.req(API_ACCOUNT_LOGOUT % self.ck())
        self.cookies = {}
        self.user_alias = None
        self.persist()
405632
def logout(self):
        
        self.client.write('exit\r\n')
        self.client.read_all()
        self.client.close()
1374569
def close_application(self):
        """"""
        self._debug('Closing application with session id %s' % self._current_application().session_id)
        self._cache.close()
94312
def end_user_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/end_users/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1272762
def kill_current_session(ctx: Context_T) -> None:
    
    ctx_id = context_id(ctx)
    if ctx_id in _sessions:
        del _sessions[ctx_id]
1070872
def stop(self):
        '''
        
        '''
        log.info('Stopping auth process')
        self.__up = False
        self.socket.close()
1209285
def logout(self):
        

        self.revoke_refresh_token()
        self.revoke_access_token()

        self._username, self._password = None, None
729011
def terminate(self, reboot=False):
        """"""
        self.root.manage.manage = False
        self.root.mode = 'delete'
        self.root.init_boot = reboot
        self.client.set_profile(self.root.get_json())
338859
def logout_user(self):
        

        for key in ('identity.name', 'identity.auth_type'):
            session.pop(key, None)
        _logout_user()
        identity_changed.send(app._get_current_object(),
                              identity=AnonymousIdentity())
874472
def logout (self):
        '''
        '''
        self.sendline("exit")
        index = self.expect([EOF, "(?i)there are stopped jobs"])
        if index==1:
            self.sendline("exit")
            self.expect(EOF)
        self.close()
963611
def destroy(self):
		
		if self.session_type == 'bash':
			# TODO: does this work/handle already being logged out/logged in deep OK?
			self.logout()
		elif self.session_type == 'vagrant':
			# TODO: does this work/handle already being logged out/logged in deep OK?
			self.logout()
845856
def terminate(self):
        
        rs = self.connection.terminate_instances([self.id])
        if len(rs) > 0:
            self._update(rs[0])
391762
def close(self):
        """"""
        if isinstance(self._session, requests.Session):
            self._session.close()
729643
async def close_authenticator_async(self):
        """"""
        _logger.info("Shutting down CBS session on connection: %r.", self._connection.container_id)
        try:
            self._cbs_auth.destroy()
            _logger.info("Auth closed, destroying session on connection: %r.", self._connection.container_id)
            await self._session.destroy_async()
        finally:
            _logger.info("Finished shutting down CBS session on connection: %r.", self._connection.container_id)
159564
def end(self):
        """"""
        if not self.args.disable_autodiscover:
            self.autodiscover_client.close()
        self.server.end()
618363
public static function end()
    {
        // If the session is ended while in cart or pending state, remove the reservation.
        // The session is only ended in these states when iffy business is going on.
        if (in_array(self::get()->Status, array('CART', 'PENDING'))) {
            self::get()->delete();
        }

        Session::set(self::KEY, null);
        Session::clear(self::KEY);
    }