CERN logout view.
165970
def logout():
    """"""
    logout_url = REMOTE_APP['logout_url']

    apps = current_app.config.get('OAUTHCLIENT_REMOTE_APPS')
    if apps:
        cern_app = apps.get('cern', REMOTE_APP)
        logout_url = cern_app['logout_url']

    return redirect(logout_url, code=302)
514596
def logout(session, cookies, csrf_token):
    '''
    
    '''
    payload = {"jsonrpc": "2.0",
               "id": "ID0",
               "method": "logout",
               "params": []
               }
    session.post(DETAILS['url'],
                 data=json.dumps(payload),
                 cookies=cookies,
                 headers={'X-CSRF-Token': csrf_token})
54307
def logout(self):
        
        if self.logged_on:
            self.logged_on = False
            self.send(MsgProto(EMsg.ClientLogOff))
            try:
                self.wait_event(self.EVENT_DISCONNECTED, timeout=5, raises=True)
            except:
                self.disconnect()
            self.idle()
1209387
def logout(self):
        """"""
        logger.debug('Logout')
        method = self._anaconda_client_api.remove_authentication
        return self._create_worker(method)
1233192
public void logout() {
        if (vimService != null) {
            try {
                serviceInstance.getSessionManager().logout();
            }
            catch (Exception e) {
                System.err.println("Failed to disconnect...");
            }
            vimService = null;
            serviceInstance = null;
        }
    }
639357
@Programmatic
    public void logoutAllSessions(final Timestamp logoutTimestamp) {

        final PersistenceManager pm = isisJdoSupport.getJdoPersistenceManager();

        final Properties properties = pm.getPersistenceManagerFactory().getProperties();
        if(isTrue(properties.get(DN_BULK_UPDATES_KEY))) {
            final javax.jdo.Query jdoQuery = pm.newNamedQuery(SessionLogEntry.class, "logoutAllActiveSessions");

            final Map argumentsByParameterName = ImmutableMap.of(
                    "logoutTimestamp", logoutTimestamp,
                    "causedBy2", SessionLogEntry.CausedBy2.RESTART);
            try {
                final Long numRows = (Long) jdoQuery.executeWithMap(argumentsByParameterName);
            } finally {
                jdoQuery.closeAll();
            }
        } else {
            final List<SessionLogEntry> activeEntries =
                    repositoryService.allMatches(new QueryDefault<>(SessionLogEntry.class, "listAllActiveSessions"));
            for (SessionLogEntry activeEntry : activeEntries) {
                activeEntry.setCausedBy2(SessionLogEntry.CausedBy2.RESTART);
                activeEntry.setLogoutTimestamp(logoutTimestamp);
            }
        }
    }
1125329
public function logout()
    {
        $this->getAuthenticationAdapter()->resetAdapters();
        $this->getAuthenticationAdapter()->logoutAdapters();
        $this->getAuthenticationService()->clearIdentity();
    }
1371645
@Subscribe
    public void onLogout(LogoutRequestEvent event) {
        Subject subject = ThreadContext.getSubject();
        if (subject != null) {
            subject.logout();
        }
    }
451796
def logout(lancet, service):
    """"""
    if service:
        services = [service]
    else:
        services = ['tracker', 'harvest']

    for service in services:
        url = lancet.config.get(service, 'url')
        key = 'lancet+{}'.format(url)
        username = lancet.config.get(service, 'username')
        with taskstatus('Logging out from {}', url) as ts:
            if keyring.get_password(key, username):
                keyring.delete_password(key, username)
                ts.ok('Logged out from {}', url)
            else:
                ts.ok('Already logged out from {}', url)
805922
public static function logout() {
    self::clearSession();
    $appUrlParts = parse_url(self::$config['app_url']);
    setcookie(
        'TILMELDAUTH',
        '',
        null,
        $appUrlParts['path'],
        $appUrlParts['host']
    );
  }
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'))
1286509
async def delView(self, iden):
        '''
        
        '''
        if iden == self.iden:
            raise s_exc.SynErr(mesg='cannot delete the main view')

        view = self.views.pop(iden, None)
        if view is None:
            raise s_exc.NoSuchView(iden=iden)

        await self.hive.pop(('cortex', 'views', iden))
        await view.fini()
1181219
def _logout(self):
        
        self.log.debug("Logging out from session ID: %s" % self._token)
        try:
            info = self._xmlrpc_server.LogOut(self._token)
            self.log.debug("Logout ended in %s with status: %s" %
                           (info['seconds'], info['status']))
        except ProtocolError as e:
            self.log.debug("error in HTTP/HTTPS transport layer")
            raise
        except Fault as e:
            self.log.debug("error in xml-rpc server")
            raise
        except:
            self.log.exception("Connection to the server failed/other error")
            raise
        finally:
            # force token reset
            self._token = None
885506
protected void createLogoutViewState(final Flow flow) {
        val logoutView = createEndState(flow, CasWebflowConstants.STATE_ID_LOGOUT_VIEW, "casLogoutView");
        logoutView.getEntryActionList().add(createEvaluateAction(CasWebflowConstants.ACTION_ID_LOGOUT_VIEW_SETUP));
    }
269247
def logout():
    

    cas_username_session_key = current_app.config['CAS_USERNAME_SESSION_KEY']
    cas_attributes_session_key = current_app.config['CAS_ATTRIBUTES_SESSION_KEY']

    if cas_username_session_key in flask.session:
        del flask.session[cas_username_session_key]

    if cas_attributes_session_key in flask.session:
        del flask.session[cas_attributes_session_key]

    if(current_app.config['CAS_AFTER_LOGOUT'] is not None):
        redirect_url = create_cas_logout_url(
            current_app.config['CAS_SERVER'],
            current_app.config['CAS_LOGOUT_ROUTE'],
            current_app.config['CAS_AFTER_LOGOUT'])
    else:
        redirect_url = create_cas_logout_url(
            current_app.config['CAS_SERVER'],
            current_app.config['CAS_LOGOUT_ROUTE'])

    current_app.logger.debug('Redirecting to: {0}'.format(redirect_url))
    return flask.redirect(redirect_url)
923723
def Logout(self, dumpXml=None):
		
		from UcsBase import UcsException

		if (self._cookie == None):
			return True

		if self._refreshTimer:
			self._refreshTimer.cancel()

		response = self.AaaLogout(dumpXml)
		self._cookie = None
		self._lastUpdateTime = str(time.asctime())
		self._domains = None
		self._priv = None
		self._sessionId = None
		self._version = None

		if self._ucs in defaultUcs:
			del defaultUcs[self._ucs]

		if (response.errorCode != 0):
			raise UcsException(response.errorCode, response.errorDescr)
		# raise Exception('[Error]: Logout [Code]:' + response.errorCode + '[Description]:' + response.errorDescr)

		return True
556824
def logout(self,
	           command='exit',
	           note=None,
	           echo=None,
	           timeout=shutit_global.shutit_global_object.default_timeout,
	           nonewline=False,
	           loglevel=logging.DEBUG):
		
		shutit_global.shutit_global_object.yield_to_draw()
		shutit_pexpect_session = self.get_current_shutit_pexpect_session()
		return shutit_pexpect_session.logout(ShutItSendSpec(shutit_pexpect_session,
		                                                    send=command,
		                                                    note=note,
		                                                    timeout=timeout,
		                                                    nonewline=nonewline,
		                                                    loglevel=loglevel,
		                                                    echo=echo))