Invoke default Shutdown Handler.

@param bool $forceKill
963840
public static function handleShutdown($forceKill = false)
    {
        $err = error_get_last();

        try
        {
            static::handleError($err['type'], $err['message'], $err['file'], $err['line']);
        }
        catch (\Error $ex)
        {
            echo call_user_func(static::$errHandler, $ex) . PHP_EOL;
        }
        catch (\Exception $ex)
        {
            echo call_user_func(static::$excHandler, $ex) . PHP_EOL;
        }

        if ($forceKill)
        {
            posix_kill(posix_getpid(), 9);
        }
    }
911754
public function close( $quit = FALSE )
	{
		if( !$quit )
			$this->checkConnection( TRUE, FALSE );
		if( !@ftp_quit( $this->resource ) )
			return FALSE;
		$this->auth		= FALSE;
		$this->resource	= NULL;
		return TRUE;
	}
895252
public function shutdownHandler()
    {
        $lastError = error_get_last();

        if (is_array($lastError)) {
            $this->errorHandler(
                $lastError[ 'type' ],
                $lastError[ 'message' ],
                $lastError[ 'file' ],
                $lastError[ 'line' ]
            );
        }

        // Execute shutdown service
        if(services()->has('shutdown')) {
            shutdown()->execute();
        }
    }
527878
public function beforeDelete( $forced = false )
  {
    try {
        if($this->resourceLog) {
            $this->resourceLog->delete();
        }
    } catch(Execption $e) {}

    return true;
  }
944657
public static function shutdownHandler($type = E_ERROR)
    {
//echo __METHOD__;
        $error = error_get_last();
        if ($error["type"] & $type) {
            self::errorHandler( $error["type"], $error["message"], $error["file"], $error["line"] );
        }
    }
1102253
public function shutdown($status = 0, $info = null)
    {
        if (!$this->process->isExit()) {
            $this->process->status = $status;
            $this->emit('exit', $status, $info);
            $this->process->emit('exit', $status, $info);
        }
    }
732304
public function shutdownHandler()
    {
        $error = error_get_last();

        if(!is_null($error)) {
            $this->exceptionHandler(new FatalErrorException($error['message'], $error['type'], 0, $error['file'], $error['line'], 0));
        }
    }
1110735
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) {
                LoggerUtils::log(LogLevel::CRITICAL, $message);
            }
        }
    }
211884
public function shutdownObject()
    {
        $this->internalPsrCompatibleLogger = null;
        foreach ($this->backends as $backend) {
            $backend->close();
        }
    }
135041
public function unregisterFatalAction()
    {
        $this->fatalShouldActive = false;

        if ($this::$krexxFatal === null) {
            // There is no fatal error handler to begin with.
            return $this;
        }

        // Now we need to tell the shutdown function, that is must
        // not do anything on shutdown.
        $this::$krexxFatal->setIsActive(false);
        unregister_tick_function(array($this::$krexxFatal, 'tickCallback'));
        return $this;
    }
468673
public function handleClose()
    {
        if ($this->autoClose === true && is_resource($this->resource))
        {
            fclose($this->resource);
        }
    }
1336469
public static function shutdown()
    {
        if (\is_null($e = \error_get_last()) === false) {
            self::exceptionHandler(new \sb\Exception($e['type'], $e['message'], $e['file'], $e['line']));
        }
    }
234258
public static function shutdownHandler()
    {
        if ($err = error_get_last()) {
            switch ($err['type']) {
                case E_ERROR:
                case E_PARSE:
                case E_COMPILE_ERROR:
                case E_CORE_ERROR:
                    $service = self::$psrLogger
                        ->getMetadataProvider()
                        ->serviceId();
                    $version = self::$psrLogger
                        ->getMetadataProvider()
                        ->versionId();
                    $message = sprintf(
                        '%s: %s in %s on line %d',
                        self::getErrorPrefix($err['type']),
                        $err['message'],
                        $err['file'],
                        $err['line']
                    );
                    $context = [
                        'context' => [
                            'reportLocation' => [
                                'filePath' => $err['file'],
                                'lineNumber' => $err['line'],
                                'functionName' =>
                                    self::getFunctionNameForReport(),
                            ]
                        ],
                        'serviceContext' => [
                            'service' => $service,
                            'version' => $version
                        ]
                    ];
                    if (self::$psrLogger) {
                        self::$psrLogger->log(
                            self::getErrorLevelString($err['type']),
                            $message,
                            $context
                        );
                    }
                    break;
            }
        }
    }
874208
protected function disconnect($quit = true)
        {
            if ($quit) {
                $this->quit();
            }
            if ($this->connected()) {
                $this->debug('Closing socket to ' . $this->host);
                fclose($this->socket);
            }
            $this->host = null;
            $this->reset_state();
        }
405424
public function shutdownHandler()
    {
        $lastError = error_get_last();

        if (is_array($lastError)) {
            $this->errorHandler(
                $lastError[ 'type' ],
                $lastError[ 'message' ],
                $lastError[ 'file' ],
                $lastError[ 'line' ]
            );
        }
    }
632627
public final function shutdown(array $error = null)
   {
       if ($error || ($error = error_get_last())) {
           $this->handle(
               $error[static::TYPE],
               $error[static::MESSAGE],
               $error[static::FILE],
               $error[static::LINE]
           );
       }
   }
938997
function shutdown()
    {
        foreach ($this->listEvents() as $event)
            $this->byEvent($event)->stopPropagation();

        $this->stopPropagation();

        $this->isShutdown = true;
        return $this;
    }