Shuts down this Object Container by calling the shutdown methods of all
object instances which were configured to be shut down.

@return void
19663
public function shutdown()
    {
        $this->callShutdownMethods($this->shutdownObjects);

        $securityContext = $this->get(Context::class);
        /** @var Context $securityContext */
        if ($securityContext->isInitialized()) {
            $this->get(Context::class)->withoutAuthorizationChecks(function () {
                $this->callShutdownMethods($this->internalShutdownObjects);
            });
        } else {
            $this->callShutdownMethods($this->internalShutdownObjects);
        }
    }
1095740
public static function shutdown()
    {
        global $PPHP;
        $req = grab('request');

        if (!$req['binary']) {
            $body = ob_get_contents();
            ob_end_clean();
            try {
                array_merge_assoc(
                    self::$_stash,
                    array(
                        'body' => self::$_safeBody,
                        'stdout' => $body,
                        'config' => $PPHP['config'],
                        'session' => $_SESSION,
                        'req' => grab('request')
                    )
                );
                self::$_template->displayBlock('body', self::$_stash);
            } catch (\Exception $e) {
                echo $e->getMessage();
            };
        };
    }
354901
void shutdown() throws IOException {
        synchronized (this) {
            for (BdbEnvironmentInfo envInfo : this.envInfos) {
                try {
                    envInfo.getClassCatalog().close();
                } catch (DatabaseException ignore) {
                    LOGGER.log(Level.SEVERE, "Failure closing class catalog", ignore);
                }
                envInfo.closeAndRemoveAllDatabaseHandles();
                
                try (Environment env = envInfo.getEnvironment()) {
                    if (this.deleteOnExit) {
                        FileUtil.deleteDirectory(env.getHome());
                    }
                }
            }
            this.envInfos.clear();
        }
    }
1222406
public function shutdownFunction() {
		if(($e=error_get_last()) && $e !== static::$errorAtStart) {
			foreach($this->ignoreDirs as $dir) {
				if(strpos($e['file'], $dir) === 0)
					return;
			}

			while(ob_get_level()) ob_end_clean();
			$exceptionHandler = set_exception_handler(function() {});
			restore_exception_handler();
			$exception = new FatalErrorException($e['message'], $e['type'], 0, $e['file'], $e['line']);
			call_user_func_array($exceptionHandler, [$exception]);
		}
	}
207506
public void shutdown(){
        synchronized(this){
            if(! isShutdown){
                if (directoryManagerFactory != null) {
                    if (directoryManagerFactory instanceof Closable) {
                        ((Closable) directoryManagerFactory).stop();
                    }
                    directoryManagerFactory = null;
                }
                if (client != null) {
                    client.close();
                    client = null;
                }
                this.isShutdown = true;
            }
        }
    }
187617
public function close()
    {
        if (!$this->freed) {
            $this->freed = true;
            if (isset($this->bev)) {
                $this->bev->free();
            }
            $this->bev = null;
            //$this->eventLoop->interrupt();
        }
        if ($this->pool) {
            $this->pool->detach($this);
        }
    }
583928
public function shutdown()
    {

        // check if there was a fatal error caused shutdown
        if ($lastError = error_get_last()) {
            // initialize error type and message
            $type = 0;
            $message = '';
            // extract the last error values
            extract($lastError);
            // query whether we've a fatal/user error
            if ($type === E_ERROR || $type === E_USER_ERROR) {
                $this->log(LogLevel::ERROR, $message);
            }
        }
    }
422419
public function shutdown()
    {
        if ($this->childPID) {
            $this->logger->notice('{type}: QUIT received; shutting down after child completes work', $this->logContext);
        } else {
            $this->logger->notice('{type}: QUIT received; shutting down', $this->logContext);
        }
        $this->doShutdown();
    }
77343
public function shutdownHandler()
    {
        $error = error_get_last();

        if (isset($error['type']) && in_array($error['type'], $this->getFatalErrorTypes())) {
            $this->log('php_shutdown', $error, 'danger', false);
        }
    }
206678
public function shutdown()
    {
        if ($this->ondebug === TRUE)
        {
            $this->_debugs[] = $this->log_debug_event('end') . PHP_EOL;
        }
        $this->sync();
    }
1007450
public function shutdownProcesses()
    {
        foreach ($this->processes as $pid => $process) {
            unset($this->processes[$pid]);
    
            posix_kill($pid, SIGUSR1);
        }
    
        exit;
    }
325059
final public function shutdown() {
		if ($this->request_handled)
			return;
		$code = 501;
		if (in_array($this->request_method, $this->method_collection))
			$code = 404;
		self::$logger->info(sprintf(
			"Router: shutdown %s in %s '%s'.",
			$code, $this->request_method, $this->request_path));
		$this->abort($code);
	}
582867
static public function _registered_shutdown()
	{
		if( self::$_byPassCallBacks )
		{
			return;
		}
		#- first sort the stack
		uasort( self::$_registeredCallbacks, array( __class__, '_compare' ) );
		foreach( self::$_registeredCallbacks as $cb )
		{
			call_user_func_array( $cb[ 0 ], $cb[ 3 ] );
		}
	}
1163374
public function shutdownObject()
    {
        if ($this->tagsToFlush !== []) {
            foreach ($this->tagsToFlush as $tag => $logMessage) {
                $affectedEntries = $this->contentCache->flushByTag($tag);
                if ($affectedEntries > 0) {
                    $this->systemLogger->debug(sprintf('Content cache: Removed %s entries %s', $affectedEntries, $logMessage));
                }
            }
        }
    }
480170
public function stop()
    {

        // load the queue keys
        $queues = get_object_vars($this->getQueues());

        // iterate over the queues and shut them down
        /** @var AppserverIo\Psr\Pms\QueueInterface $queue */
        foreach ($queues as $queue) {
            $queue->stop();
        }
    }
35091
public static function __shutdownCleanup()
    {
        $now = time();

        if (is_array(self::$lockFiles)) {
            foreach (self::$lockFiles as $lockFile => $meta) {
                if (($now - $meta['time'] > $meta['ttl']) && file_exists($lockFile)) {
                    unlink($lockFile);
                }
            }
        }
    }
274511
public function shutdown()
    {

        // check if there was a fatal error caused shutdown
        if ($lastError = error_get_last()) {
            // initialize type + message
            $type = 0;
            $message = '';
            // extract the last error values
            extract($lastError);
            // query whether we've a fatal/user error
            if ($type === E_ERROR || $type === E_USER_ERROR) {
                $this->getApplication()->getInitialContext()->getSystemLogger()->error($message);
            }
        }
    }