Closes user session
175554
public function closeAccount()
    {
        if (!$this->session->has('session_id')) {
            throw new RuntimeException('No session to close.');
        }

        if (null !== $session = $this->app['repo.sessions']->find($this->session->get('session_id'))) {
            $this->em->remove($session);
            $this->em->flush();
        }

        $this->session->invalidate();
        $this->reinitUser();

        return $this;
    }
954609
@Override
    public void close() {
        if (isClosed())
            return;

        // Set the session state to ENDED.
        setSessionState(JingleSessionStateEnded.getInstance());

        for (ContentNegotiator contentNegotiator : contentNegotiators) {

            contentNegotiator.stopJingleMediaSession();

            for (TransportCandidate candidate : contentNegotiator.getTransportNegotiator().getOfferedCandidates())
                candidate.removeCandidateEcho();

            contentNegotiator.close();
        }
        removeAsyncPacketListener();
        removeConnectionListener();
        getConnection().removeConnectionListener(connectionListener);
        LOGGER.fine("Negotiation Closed: " + getConnection().getUser() + " " + sid);
        super.close();

    }
471912
public function close(){
        if($this->status() !== self::ACTIVE){
            throw Exception\SessionException::notStarted();
        }

        session_commit();
        
        $this->finishedData = $_SESSION;
    }
34423
def kill_session(self):
        """"""

        proc = self.cmd('kill-session', '-t%s' % self.id)

        if proc.stderr:
            raise exc.LibTmuxException(proc.stderr)
83326
def detach_session(self):
        """"""
        if self._session is not None:
            self._session.unsubscribe(self)
            self._session = None
1049685
def deactivate_user(self, user):
        
        res = super(SessionAwareSQLAlchemyUserDatastore, self).deactivate_user(
            user)
        if res:
            delete_user_sessions(user)
        return res
20276
@Override
	public void close() {
		if(userSession == null) {
			return;
		}
		
		try {
			final CloseReason closeReason = new CloseReason(CloseCodes.NORMAL_CLOSURE, "Socket closed");
			userSession.close(closeReason);
		} catch (Throwable e) {
			logger.error("Got exception while closing socket", e);
		}
		
		userSession = null;
	}
1193282
def close(self):
        ''''''
        if self._save_filename:
            self._cookie_jar.save(
                self._save_filename,
                ignore_discard=self._keep_session_cookies
            )
823113
protected final void closeSession() {
        if (sessionTracker != null) {
            Session currentSession = sessionTracker.getOpenSession();
            if (currentSession != null) {
                currentSession.close();
            }
        }
    }
1364496
public function wipeLoginSession() {
		$stmt = $this->db->prepare("DELETE FROM sessions WHERE user_id = ?;");
		$stmt->bind_param("i", $this->user->id);
		$stmt->execute();
		$this->db->commit();
	}
567203
def close(self, wait=False):
        """"""
        self.session.close()
        self.pool.shutdown(wait=wait)
421098
public static function Close () {
		if (!static::GetStarted()) return;
		register_shutdown_function(function () {
			foreach (static::$instances as & $instance)
				if (count((array) $_SESSION[$instance->__name]) === 0)
					// if there is nothing in namespace - destroy it. It's useless.
					$instance->Destroy();
			$metaKey = static::SESSION_METADATA_KEY;
			$_SESSION[$metaKey] = serialize(static::$meta);
			@session_write_close();
		});
	}
930459
public void endSession() {
		if (replayWindow != null) {
			replayWindow.removeAllElements();
		}
		replayWindow = null;
		txEncryptorSuite = rxEncryptorSuite = null;
		txIV = rxIV = null;
		txEncOut = rxEncOut = null;
		txHMAC = rxHMAC = null;
		txSessEncKey = null;
		txSessAuthKey = null;
		txSessSaltKey = null;
		rxSessEncKey = null;
		rxSessAuthKey = null;
		rxSessSaltKey = null;
		firstRtpSeq = 1;
		rollOverCounter = 0;
	}
715423
def close(self):
        """"""

        if hasattr(self, "conn"):
            self.conn.close()
            del self.conn
        if hasattr(self, "user"):
            del self.user
391762
def close(self):
        """"""
        if isinstance(self._session, requests.Session):
            self._session.close()
683467
async def close_websession(self):
        """"""
        # We do not close the web session if it was provided.
        if self._supplied_websession or self._websession is None:
            return

        _LOGGER.debug('Closing connections')
        # Need to set _websession to none first to prevent any other task
        # from closing it as well.
        temp_websession = self._websession
        self._websession = None
        await temp_websession.close()
        await asyncio.sleep(0)
        _LOGGER.debug('Connections closed')
353537
public static void closeQuietly(final Session session)
    {
        if (session != null) {
            try {
                session.close();
            }
            catch (JMSException je) {
                if (je.getCause() instanceof InterruptedException) {
                    LOG.trace("ActiveMQ caught and wrapped InterruptedException");
                }
                if (je.getCause() instanceof InterruptedIOException) {
                    LOG.trace("ActiveMQ caught and wrapped InterruptedIOException");
                }
                else {
                    LOG.warnDebug(je, "While closing session");
                }
            }
        }
    }