interface/modules/zend_modules/library/Zend/Mvc/Application.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Mvc;
  11
  12 use Zend\EventManager\EventManagerAwareInterface;
  13 use Zend\EventManager\EventManagerInterface;
  14 use Zend\ServiceManager\ServiceManager;
  15 use Zend\Stdlib\ResponseInterface;
  16
  17 /**
  18  * Main application class for invoking applications
  19  *
  20  * Expects the user will provide a configured ServiceManager, configured with
  21  * the following services:
  22  *
  23  * - EventManager
  24  * - ModuleManager
  25  * - Request
  26  * - Response
  27  * - RouteListener
  28  * - Router
  29  * - DispatchListener
  30  * - ViewManager
  31  *
  32  * The most common workflow is:
  33  * <code>
  34  * $services = new Zend\ServiceManager\ServiceManager($servicesConfig);
  35  * $app      = new Application($appConfig, $services);
  36  * $app->bootstrap();
  37  * $response = $app->run();
  38  * $response->send();
  39  * </code>
  40  *
  41  * bootstrap() opts in to the default route, dispatch, and view listeners,
  42  * sets up the MvcEvent, and triggers the bootstrap event. This can be omitted
  43  * if you wish to setup your own listeners and/or workflow; alternately, you
  44  * can simply extend the class to override such behavior.
  45  */
  46 class Application implements
  47     ApplicationInterface,
  48     EventManagerAwareInterface
  49 {
  50     const ERROR_CONTROLLER_CANNOT_DISPATCH = 'error-controller-cannot-dispatch';
  51     const ERROR_CONTROLLER_NOT_FOUND       = 'error-controller-not-found';
  52     const ERROR_CONTROLLER_INVALID         = 'error-controller-invalid';
  53     const ERROR_EXCEPTION                  = 'error-exception';
  54     const ERROR_ROUTER_NO_MATCH            = 'error-router-no-match';
  55
  56     /**
  57      * @var array
  58      */
  59     protected $configuration = null;
  60
  61     /**
  62      * Default application event listeners
  63      *
  64      * @var array
  65      */
  66     protected $defaultListeners = array(
  67         'RouteListener',
  68         'DispatchListener',
  69         'ViewManager',
  70         'SendResponseListener',
  71     );
  72
  73     /**
  74      * MVC event token
  75      * @var MvcEvent
  76      */
  77     protected $event;
  78
  79     /**
  80      * @var EventManagerInterface
  81      */
  82     protected $events;
  83
  84     /**
  85      * @var \Zend\Stdlib\RequestInterface
  86      */
  87     protected $request;
  88
  89     /**
  90      * @var ResponseInterface
  91      */
  92     protected $response;
  93
  94     /**
  95      * @var ServiceManager
  96      */
  97     protected $serviceManager = null;
  98
  99     /**
 100      * Constructor
 101      *
 102      * @param mixed $configuration
 103      * @param ServiceManager $serviceManager
 104      */
 105     public function __construct($configuration, ServiceManager $serviceManager)
 106     {
 107         $this->configuration  = $configuration;
 108         $this->serviceManager = $serviceManager;
 109
 110         $this->setEventManager($serviceManager->get('EventManager'));
 111
 112         $this->request        = $serviceManager->get('Request');
 113         $this->response       = $serviceManager->get('Response');
 114     }
 115
 116     /**
 117      * Retrieve the application configuration
 118      *
 119      * @return array|object
 120      */
 121     public function getConfig()
 122     {
 123         return $this->serviceManager->get('Config');
 124     }
 125
 126     /**
 127      * Bootstrap the application
 128      *
 129      * Defines and binds the MvcEvent, and passes it the request, response, and
 130      * router. Attaches the ViewManager as a listener. Triggers the bootstrap
 131      * event.
 132      *
 133      * @param array $listeners List of listeners to attach.
 134      * @return Application
 135      */
 136     public function bootstrap(array $listeners = array())
 137     {
 138         $serviceManager = $this->serviceManager;
 139         $events         = $this->events;
 140
 141         $listeners = array_unique(array_merge($this->defaultListeners, $listeners));
 142
 143         foreach ($listeners as $listener) {
 144             $events->attach($serviceManager->get($listener));
 145         }
 146
 147         // Setup MVC Event
 148         $this->event = $event  = new MvcEvent();
 149         $event->setTarget($this);
 150         $event->setApplication($this)
 151               ->setRequest($this->getRequest())
 152               ->setResponse($this->getResponse())
 153               ->setRouter($serviceManager->get('Router'));
 154
 155         // Trigger bootstrap events
 156         $events->trigger(MvcEvent::EVENT_BOOTSTRAP, $event);
 157         return $this;
 158     }
 159
 160     /**
 161      * Retrieve the service manager
 162      *
 163      * @return ServiceManager
 164      */
 165     public function getServiceManager()
 166     {
 167         return $this->serviceManager;
 168     }
 169
 170     /**
 171      * Get the request object
 172      *
 173      * @return \Zend\Stdlib\RequestInterface
 174      */
 175     public function getRequest()
 176     {
 177         return $this->request;
 178     }
 179
 180     /**
 181      * Get the response object
 182      *
 183      * @return ResponseInterface
 184      */
 185     public function getResponse()
 186     {
 187         return $this->response;
 188     }
 189
 190     /**
 191      * Get the MVC event instance
 192      *
 193      * @return MvcEvent
 194      */
 195     public function getMvcEvent()
 196     {
 197         return $this->event;
 198     }
 199
 200     /**
 201      * Set the event manager instance
 202      *
 203      * @param  EventManagerInterface $eventManager
 204      * @return Application
 205      */
 206     public function setEventManager(EventManagerInterface $eventManager)
 207     {
 208         $eventManager->setIdentifiers(array(
 209             __CLASS__,
 210             get_class($this),
 211         ));
 212         $this->events = $eventManager;
 213         return $this;
 214     }
 215
 216     /**
 217      * Retrieve the event manager
 218      *
 219      * Lazy-loads an EventManager instance if none registered.
 220      *
 221      * @return EventManagerInterface
 222      */
 223     public function getEventManager()
 224     {
 225         return $this->events;
 226     }
 227
 228     /**
 229      * Static method for quick and easy initialization of the Application.
 230      *
 231      * If you use this init() method, you cannot specify a service with the
 232      * name of 'ApplicationConfig' in your service manager config. This name is
 233      * reserved to hold the array from application.config.php.
 234      *
 235      * The following services can only be overridden from application.config.php:
 236      *
 237      * - ModuleManager
 238      * - SharedEventManager
 239      * - EventManager & Zend\EventManager\EventManagerInterface
 240      *
 241      * All other services are configured after module loading, thus can be
 242      * overridden by modules.
 243      *
 244      * @param array $configuration
 245      * @return Application
 246      */
 247     public static function init($configuration = array())
 248     {
 249         $smConfig = isset($configuration['service_manager']) ? $configuration['service_manager'] : array();
 250         $listeners = isset($configuration['listeners']) ? $configuration['listeners'] : array();
 251         $serviceManager = new ServiceManager(new Service\ServiceManagerConfig($smConfig));
 252         $serviceManager->setService('ApplicationConfig', $configuration);
 253         $serviceManager->get('ModuleManager')->loadModules();
 254         return $serviceManager->get('Application')->bootstrap($listeners);
 255     }
 256
 257     /**
 258      * Run the application
 259      *
 260      * @triggers route(MvcEvent)
 261      *           Routes the request, and sets the RouteMatch object in the event.
 262      * @triggers dispatch(MvcEvent)
 263      *           Dispatches a request, using the discovered RouteMatch and
 264      *           provided request.
 265      * @triggers dispatch.error(MvcEvent)
 266      *           On errors (controller not found, action not supported, etc.),
 267      *           populates the event with information about the error type,
 268      *           discovered controller, and controller class (if known).
 269      *           Typically, a handler should return a populated Response object
 270      *           that can be returned immediately.
 271      * @return ResponseInterface
 272      */
 273     public function run()
 274     {
 275         $events = $this->getEventManager();
 276         $event  = $this->getMvcEvent();
 277
 278         // Define callback used to determine whether or not to short-circuit
 279         $shortCircuit = function ($r) use ($event) {
 280             if ($r instanceof ResponseInterface) {
 281                 return true;
 282             }
 283             if ($event->getError()) {
 284                 return true;
 285             }
 286             return false;
 287         };
 288
 289         // Trigger route event
 290         $result = $events->trigger(MvcEvent::EVENT_ROUTE, $event, $shortCircuit);
 291         if ($result->stopped()) {
 292             $response = $result->last();
 293             if ($response instanceof ResponseInterface) {
 294                 $event->setTarget($this);
 295                 $event->setResponse($response);
 296                 $events->trigger(MvcEvent::EVENT_FINISH, $event);
 297                 return $response;
 298             }
 299             if ($event->getError()) {
 300                 return $this->completeRequest($event);
 301             }
 302             return $event->getResponse();
 303         }
 304         if ($event->getError()) {
 305             return $this->completeRequest($event);
 306         }
 307
 308         // Trigger dispatch event
 309         $result = $events->trigger(MvcEvent::EVENT_DISPATCH, $event, $shortCircuit);
 310
 311         // Complete response
 312         $response = $result->last();
 313         if ($response instanceof ResponseInterface) {
 314             $event->setTarget($this);
 315             $event->setResponse($response);
 316             $events->trigger(MvcEvent::EVENT_FINISH, $event);
 317             return $response;
 318         }
 319
 320         $response = $this->getResponse();
 321         $event->setResponse($response);
 322         $this->completeRequest($event);
 323
 324         return $this;
 325     }
 326
 327     /**
 328      * @deprecated
 329      */
 330     public function send()
 331     {
 332     }
 333
 334     /**
 335      * Complete the request
 336      *
 337      * Triggers "render" and "finish" events, and returns response from
 338      * event object.
 339      *
 340      * @param  MvcEvent $event
 341      * @return Application
 342      */
 343     protected function completeRequest(MvcEvent $event)
 344     {
 345         $events = $this->getEventManager();
 346         $event->setTarget($this);
 347         $events->trigger(MvcEvent::EVENT_RENDER, $event);
 348         $events->trigger(MvcEvent::EVENT_FINISH, $event);
 349         return $this;
 350     }
 351 }