Exemple #1
0
    /**
     * Dispatch an HTTP request to a controller/action.
     *
     * @param \Zend\Controller\Request\AbstractRequest|null $request
     * @param \Zend\Controller\Response\AbstractResponse|null $response
     * @return void|\Zend\Controller\Response\AbstractResponse Returns response object if returnResponse() is true
     */
    public function dispatch(Request\AbstractRequest $request = null, Response\AbstractResponse $response = null)
    {
        $helperBroker = $this->getHelperBroker();
        if (!$this->getParam('noErrorHandler') && !$this->_plugins->hasPlugin('\Zend\Controller\Plugin\ErrorHandler')) {
            // Register with stack index of 100
            $this->_plugins->registerPlugin(new Plugin\ErrorHandler(), 100);
        }

        if (!$this->getParam('noViewRenderer') && !$helperBroker->hasPlugin('viewRenderer')) {
            $viewRenderer = $helperBroker->load('viewrenderer');
            $helperBroker->getStack()->offsetSet(-80, $viewRenderer);
        }

        /**
         * Instantiate default request object (HTTP version) if none provided
         */
        if (null !== $request) {
            $this->setRequest($request);
        } elseif ((null === $request) && (null === ($request = $this->getRequest()))) {
            $request = new Request\Http();
            $this->setRequest($request);
        }

        /**
         * Set base URL of request object, if available
         */
        if (is_callable(array($this->_request, 'setBaseUrl'))) {
            if (null !== $this->_baseUrl) {
                $this->_request->setBaseUrl($this->_baseUrl);
            }
        }

        /**
         * Instantiate default response object (HTTP version) if none provided
         */
        if (null !== $response) {
            $this->setResponse($response);
        } elseif ((null === $this->_response) && (null === ($this->_response = $this->getResponse()))) {
            $response = new Response\Http();
            $this->setResponse($response);
        }

        /**
         * Register request and response objects with plugin broker
         */
        $this->_plugins
             ->setRequest($this->_request)
             ->setResponse($this->_response)
             ->setHelperBroker($helperBroker);

        /**
         * Initialize router
         */
        $router = $this->getRouter();
        $router->setParams($this->getParams());

        /**
         * Initialize dispatcher
         */
        $dispatcher = $this->getDispatcher();
        $dispatcher->setParams($this->getParams())
                   ->setResponse($this->_response)
                   ->setHelperBroker($helperBroker);

        // Begin dispatch
        try {
            /**
             * Route request to controller/action, if a router is provided
             */

            /**
            * Notify plugins of router startup
            */
            $this->_plugins->routeStartup($this->_request);

            try {
                $router->route($this->_request);
            }  catch (\Exception $e) {
                if ($this->throwExceptions()) {
                    throw $e;
                }

                $this->_response->setException($e);
            }

            /**
            * Notify plugins of router completion
            */
            $this->_plugins->routeShutdown($this->_request);

            /**
             * Notify plugins of dispatch loop startup
             */
            $this->_plugins->dispatchLoopStartup($this->_request);

            /**
             *  Attempt to dispatch the controller/action. If the $this->_request
             *  indicates that it needs to be dispatched, move to the next
             *  action in the request.
             */
            do {
                $this->_request->setDispatched(true);

                /**
                 * Notify plugins of dispatch startup
                 */
                $this->_plugins->preDispatch($this->_request);

                /**
                 * Skip requested action if preDispatch() has reset it
                 */
                if (!$this->_request->isDispatched()) {
                    continue;
                }

                /**
                 * Dispatch request
                 */
                try {
                    $dispatcher->dispatch($this->_request, $this->_response);
                } catch (\Exception $e) {
                    if ($this->throwExceptions()) {
                        throw $e;
                    }
                    $this->_response->setException($e);
                }

                /**
                 * Notify plugins of dispatch completion
                 */
                $this->_plugins->postDispatch($this->_request);
            } while (!$this->_request->isDispatched());
        } catch (\Exception $e) {
            if ($this->throwExceptions()) {
                throw $e;
            }

            $this->_response->setException($e);
        }

        /**
         * Notify plugins of dispatch loop completion
         */
        try {
            $this->_plugins->dispatchLoopShutdown();
        } catch (\Exception $e) {
            if ($this->throwExceptions()) {
                throw $e;
            }

            $this->_response->setException($e);
        }

        if ($this->returnResponse()) {
            return $this->_response;
        }

        $this->_response->sendResponse();
    }
Exemple #2
0
 public function testBrokerCatchesExceptions()
 {
     $request = new Request\Http('http://framework.zend.com/empty');
     $response = new Response\Cli();
     $broker = new Plugin\Broker();
     $broker->setResponse($response);
     $broker->registerPlugin(new ExceptionTestPlugin());
     try {
         $broker->routeStartup($request);
         $broker->routeShutdown($request);
         $broker->dispatchLoopStartup($request);
         $broker->preDispatch($request);
         $broker->postDispatch($request);
         $broker->dispatchLoopShutdown();
     } catch (\Exception $e) {
         $this->fail('Broker should catch exceptions');
     }
     $this->assertTrue($response->hasExceptionOfMessage('routeStartup triggered exception'));
     $this->assertTrue($response->hasExceptionOfMessage('routeShutdown triggered exception'));
     $this->assertTrue($response->hasExceptionOfMessage('dispatchLoopStartup triggered exception'));
     $this->assertTrue($response->hasExceptionOfMessage('preDispatch triggered exception'));
     $this->assertTrue($response->hasExceptionOfMessage('postDispatch triggered exception'));
     $this->assertTrue($response->hasExceptionOfMessage('dispatchLoopShutdown triggered exception'));
 }