Destroy the given session on registered SSO clients

@param \TYPO3\Flow\Session\SessionInterface $session
@return void
9209
public function destroyRegisteredSsoClientSessions(SessionInterface $session) {
		if (!$session->isStarted()) {
			return;
		}

		$ssoClients = $this->getRegisteredSsoClients($session);
		$sessionId = $session->getId();

		$ssoServer = $this->ssoServerFactory->create();
		$this->ssoClientNotifier->destroySession($ssoServer, $sessionId, $ssoClients);
	}
425979
public function destroy()
    {
        // empty
        $_SESSION = array();

        // clear cookies from agent
        $signature = ($this->_name) . 'Signature';
            setcookie(
        $this->_name,
                '',
                time() - 42000,
        $this->_path,
        $this->_host,
        $this->_secure,
        $this->_httponly
            );
            setcookie(
        $signature,
                '',
                time() - 42000,
        $this->_path,
        $this->_host,
        $this->_secure,
        $this->_httponly
            );

        /**
         * Clear out of global scope, since setcookie requires buffer flush
         * to update global <_COOKIE> array.
         */
            unset($_COOKIE[$this->_name]);
            unset($_COOKIE[$signature]);

        // destroy
            session_destroy();
    }
1158068
public function destroy($reason = null)
    {
        if ($this->started !== true) {
            throw new Exception\SessionNotStartedException('Tried to destroy a session which has not been started yet.', 1351162668);
        }

        if ($this->remote !== true) {
            $this->sessionCookie->expire();
        }

        $this->removeSessionMetaDataCacheEntry($this->sessionIdentifier);
        $this->storageCache->flushByTag($this->storageIdentifier);
        $this->started = false;
        $this->sessionIdentifier = null;
        $this->storageIdentifier = null;
        $this->tags = [];
        $this->request = null;
    }
1306471
public function destroy($sessionId) {
        try {
            $this->_tableRestProxy->deleteEntity($this->_sessionContainer, $this->_sessionContainerParition, $sessionId);
            return TRUE;
        } catch (ServiceException $e) {
            return FALSE;
        }
    }
1333858
public static function kill_session($sid) {
        global $DB;

        self::load_handler();

        if ($sid === session_id()) {
            self::write_close();
        }

        self::$handler->kill_session($sid);

        $DB->delete_records('sessions', array('sid'=>$sid));
    }
562127
private function _destroySession(ComPeopleDomainEntityPerson $person)
    {
        $this->getService('repos:sessions.session')->destroy(array('nodeId' => $person->id));
        $this->getService('com:sessions')->destroy();
    }
377457
public function destroy($sessionId)
    {
        parent::destroy($sessionId);
        if (isset($_COOKIE[$this->cookieKeyName])) {
            setcookie($this->cookieKeyName, '', 1);
            unset($_COOKIE[$this->cookieKeyName]);
        }
        return true;
    }
627318
public function destroy(): void
    {
        if (!$this->cookieExists() || !$this->sessionExists()) {
            return;
        }

        session_destroy();

        // send expire cookies
        $this->expireSessionCookie();

        // clear session data
        unset($_SESSION[$this->getNamespace()]);
    }
346129
function destroy($id) {
		Cache::instance()->clear($id.'.@');
		setcookie(session_name(),'',strtotime('-1 year'));
		unset($_COOKIE[session_name()]);
		header_remove('Set-Cookie');
		return TRUE;
	}
341826
public static void close(Session session) {
		if (session != null && session.isConnected()) {
			session.disconnect();
		}
		JschSessionPool.INSTANCE.remove(session);
	}
197221
public function destroySession(\Flowpack\SingleSignOn\Server\Domain\Model\SsoServer $ssoServer, $sessionId, array $ssoClients) {
		$requests = array();
		foreach ($ssoClients as $ssoClient) {
			/** @var \Flowpack\SingleSignOn\Server\Domain\Model\SsoClient $ssoClient */
			$request = $ssoClient->buildDestroySessionRequest($ssoServer, $sessionId);
			$this->ssoLogger->log('Destroying session "' . $sessionId . '" on client ' . $ssoClient->getServiceBaseUri(), LOG_INFO);
			$requests[] = $request;
		}
		$responses = $this->requestEngine->sendRequests($requests);

		foreach ($responses as $index => $response) {
			if ($response instanceof \TYPO3\Flow\Http\Exception) {
				$this->ssoLogger->log($response->getMessage(), LOG_WARNING);
			} elseif ($response instanceof \TYPO3\Flow\Http\Response) {
				if ($response->getStatusCode() === 404 && $response->getHeader('Content-Type') === 'application/json') {
					$data = json_decode($response->getContent(), TRUE);
						// Ignore unknown sessions, could be expired on client
					if (is_array($data) && isset($data['error']) && $data['error'] === 'SessionNotFound') {
						continue;
					}
				}

				if ($response->getStatusCode() !== 200) {
					$this->ssoLogger->log('Unexpected status code for destroy session when calling "' . (string)$requests[$index]->getUri() . '": "' . $response->getStatus() . '"', LOG_WARNING);
				}
			}
		}
	}
21055
public function destroySession() {
        if (session_status() == PHP_SESSION_ACTIVE) {
            // unset all session variables
            $_SESSION = [];

            // delete the session cookie
            if (ini_get_bool('session.use_cookies')) {
                $params = session_get_cookie_params();
                setcookie($name=session_name(), $value='', $expire=time()-1*DAY, $params['path'    ],
                                                                                 $params['domain'  ],
                                                                                 $params['secure'  ],
                                                                                 $params['httponly']);
            }
            session_destroy();                      // TODO: check if SID is reset
        }
    }
326348
public void destroySession() {
		if (entryPoint != null) {
			entryPoint.onSessionDestruction(this, session);
		}
		if (accessManager != null) {
			accessManager.destroyCurrentSession();
		}
		session = null;
	}
899529
public function destroy($id)
	{
        if ($session = $this->_getSession($id)) {
            return $this->_repository->destroy(array('sessionId' => $id));
        }

        return false;
	}
119340
public function destroy($id) {
        if (headers_sent() && !$this->sent)
            throw new \LogicException('Session data must be destroyed before headers are sent');
        if (!$this->sent)
            $this->sent = setcookie(
                $this->name,
                '',
                time() - 3600,
                '/',
                $this->getDomain(),
                null,
                true
            );
        return true;
    }
889100
public function destroy()
    {
        if (empty($this->sessionToken)) return;

        $this->userData = array();

        $this->handler->destroy($this->sessionToken);

        setcookie($this->sessionCookieName, null, $this->sessionExpiration, '/');

        $this->sessionToken = NULL;
    }
995724
public void destroySession() {
    	JsonObject session = get("session");
        if (session == null) {
            return;
        }

        String sessionId = session.getString("id");
        // remove from the context
        put("session", null);

        if (sessionId == null) {
            return;
        }

        store.destroy(sessionId, new Handler<Object>() {
            @Override
            public void handle(Object error) {
                if (error != null) {
                    // TODO: better handling of errors
                    System.err.println(error);
                }
            }
        });
    }