1: <?php
  2: /**
  3:  * ShellDispatcher file
  4:  *
  5:  * PHP 5
  6:  *
  7:  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
  8:  * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
  9:  *
 10:  * Licensed under The MIT License
 11:  * For full copyright and license information, please see the LICENSE.txt
 12:  * Redistributions of files must retain the above copyright notice.
 13:  *
 14:  * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 15:  * @link          http://cakephp.org CakePHP(tm) Project
 16:  * @since         CakePHP(tm) v 2.0
 17:  * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 18:  */
 19: 
 20: /**
 21:  * Shell dispatcher handles dispatching cli commands.
 22:  *
 23:  * @package       Cake.Console
 24:  */
 25: class ShellDispatcher {
 26: 
 27: /**
 28:  * Contains command switches parsed from the command line.
 29:  *
 30:  * @var array
 31:  */
 32:     public $params = array();
 33: 
 34: /**
 35:  * Contains arguments parsed from the command line.
 36:  *
 37:  * @var array
 38:  */
 39:     public $args = array();
 40: 
 41: /**
 42:  * Constructor
 43:  *
 44:  * The execution of the script is stopped after dispatching the request with
 45:  * a status code of either 0 or 1 according to the result of the dispatch.
 46:  *
 47:  * @param array $args the argv from PHP
 48:  * @param boolean $bootstrap Should the environment be bootstrapped.
 49:  */
 50:     public function __construct($args = array(), $bootstrap = true) {
 51:         set_time_limit(0);
 52:         $this->parseParams($args);
 53: 
 54:         if ($bootstrap) {
 55:             $this->_initConstants();
 56:             $this->_initEnvironment();
 57:         }
 58:     }
 59: 
 60: /**
 61:  * Run the dispatcher
 62:  *
 63:  * @param array $argv The argv from PHP
 64:  * @return void
 65:  */
 66:     public static function run($argv) {
 67:         $dispatcher = new ShellDispatcher($argv);
 68:         return $dispatcher->_stop($dispatcher->dispatch() === false ? 1 : 0);
 69:     }
 70: 
 71: /**
 72:  * Defines core configuration.
 73:  *
 74:  * @return void
 75:  */
 76:     protected function _initConstants() {
 77:         if (function_exists('ini_set')) {
 78:             ini_set('html_errors', false);
 79:             ini_set('implicit_flush', true);
 80:             ini_set('max_execution_time', 0);
 81:         }
 82: 
 83:         if (!defined('CAKE_CORE_INCLUDE_PATH')) {
 84:             define('DS', DIRECTORY_SEPARATOR);
 85:             define('CAKE_CORE_INCLUDE_PATH', dirname(dirname(dirname(__FILE__))));
 86:             define('CAKEPHP_SHELL', true);
 87:             if (!defined('CORE_PATH')) {
 88:                 define('CORE_PATH', CAKE_CORE_INCLUDE_PATH . DS);
 89:             }
 90:         }
 91:     }
 92: 
 93: /**
 94:  * Defines current working environment.
 95:  *
 96:  * @return void
 97:  * @throws CakeException
 98:  */
 99:     protected function _initEnvironment() {
100:         if (!$this->_bootstrap()) {
101:             $message = "Unable to load CakePHP core.\nMake sure " . DS . 'lib' . DS . 'Cake exists in ' . CAKE_CORE_INCLUDE_PATH;
102:             throw new CakeException($message);
103:         }
104: 
105:         if (!isset($this->args[0]) || !isset($this->params['working'])) {
106:             $message = "This file has been loaded incorrectly and cannot continue.\n" .
107:                 "Please make sure that " . DS . 'lib' . DS . 'Cake' . DS . "Console is in your system path,\n" .
108:                 "and check the cookbook for the correct usage of this command.\n" .
109:                 "(http://book.cakephp.org/)";
110:             throw new CakeException($message);
111:         }
112: 
113:         $this->shiftArgs();
114:     }
115: 
116: /**
117:  * Initializes the environment and loads the Cake core.
118:  *
119:  * @return boolean Success.
120:  */
121:     protected function _bootstrap() {
122:         if (!defined('ROOT')) {
123:             define('ROOT', $this->params['root']);
124:         }
125:         if (!defined('APP_DIR')) {
126:             define('APP_DIR', $this->params['app']);
127:         }
128:         if (!defined('APP')) {
129:             define('APP', $this->params['working'] . DS);
130:         }
131:         if (!defined('WWW_ROOT')) {
132:             define('WWW_ROOT', APP . $this->params['webroot'] . DS);
133:         }
134:         if (!defined('TMP') && !is_dir(APP . 'tmp')) {
135:             define('TMP', CAKE_CORE_INCLUDE_PATH . DS . 'Cake' . DS . 'Console' . DS . 'Templates' . DS . 'skel' . DS . 'tmp' . DS);
136:         }
137:         $boot = file_exists(ROOT . DS . APP_DIR . DS . 'Config' . DS . 'bootstrap.php');
138:         require CORE_PATH . 'Cake' . DS . 'bootstrap.php';
139: 
140:         if (!file_exists(APP . 'Config' . DS . 'core.php')) {
141:             include_once CAKE_CORE_INCLUDE_PATH . DS . 'Cake' . DS . 'Console' . DS . 'Templates' . DS . 'skel' . DS . 'Config' . DS . 'core.php';
142:             App::build();
143:         }
144: 
145:         $this->setErrorHandlers();
146: 
147:         if (!defined('FULL_BASE_URL')) {
148:             define('FULL_BASE_URL', 'http://localhost');
149:         }
150: 
151:         return true;
152:     }
153: 
154: /**
155:  * Set the error/exception handlers for the console
156:  * based on the `Error.consoleHandler`, and `Exception.consoleHandler` values
157:  * if they are set. If they are not set, the default ConsoleErrorHandler will be
158:  * used.
159:  *
160:  * @return void
161:  */
162:     public function setErrorHandlers() {
163:         App::uses('ConsoleErrorHandler', 'Console');
164:         $error = Configure::read('Error');
165:         $exception = Configure::read('Exception');
166: 
167:         $errorHandler = new ConsoleErrorHandler();
168:         if (empty($error['consoleHandler'])) {
169:             $error['consoleHandler'] = array($errorHandler, 'handleError');
170:             Configure::write('Error', $error);
171:         }
172:         if (empty($exception['consoleHandler'])) {
173:             $exception['consoleHandler'] = array($errorHandler, 'handleException');
174:             Configure::write('Exception', $exception);
175:         }
176:         set_exception_handler($exception['consoleHandler']);
177:         set_error_handler($error['consoleHandler'], Configure::read('Error.level'));
178:     }
179: 
180: /**
181:  * Dispatches a CLI request
182:  *
183:  * @return boolean
184:  * @throws MissingShellMethodException
185:  */
186:     public function dispatch() {
187:         $shell = $this->shiftArgs();
188: 
189:         if (!$shell) {
190:             $this->help();
191:             return false;
192:         }
193:         if (in_array($shell, array('help', '--help', '-h'))) {
194:             $this->help();
195:             return true;
196:         }
197: 
198:         $Shell = $this->_getShell($shell);
199: 
200:         $command = null;
201:         if (isset($this->args[0])) {
202:             $command = $this->args[0];
203:         }
204: 
205:         if ($Shell instanceof Shell) {
206:             $Shell->initialize();
207:             $Shell->loadTasks();
208:             return $Shell->runCommand($command, $this->args);
209:         }
210:         $methods = array_diff(get_class_methods($Shell), get_class_methods('Shell'));
211:         $added = in_array($command, $methods);
212:         $private = $command[0] === '_' && method_exists($Shell, $command);
213: 
214:         if (!$private) {
215:             if ($added) {
216:                 $this->shiftArgs();
217:                 $Shell->startup();
218:                 return $Shell->{$command}();
219:             }
220:             if (method_exists($Shell, 'main')) {
221:                 $Shell->startup();
222:                 return $Shell->main();
223:             }
224:         }
225: 
226:         throw new MissingShellMethodException(array('shell' => $shell, 'method' => $command));
227:     }
228: 
229: /**
230:  * Get shell to use, either plugin shell or application shell
231:  *
232:  * All paths in the loaded shell paths are searched.
233:  *
234:  * @param string $shell Optionally the name of a plugin
235:  * @return mixed An object
236:  * @throws MissingShellException when errors are encountered.
237:  */
238:     protected function _getShell($shell) {
239:         list($plugin, $shell) = pluginSplit($shell, true);
240: 
241:         $plugin = Inflector::camelize($plugin);
242:         $class = Inflector::camelize($shell) . 'Shell';
243: 
244:         App::uses('Shell', 'Console');
245:         App::uses('AppShell', 'Console/Command');
246:         App::uses($class, $plugin . 'Console/Command');
247: 
248:         if (!class_exists($class)) {
249:             throw new MissingShellException(array(
250:                 'class' => $class
251:             ));
252:         }
253:         $Shell = new $class();
254:         $Shell->plugin = trim($plugin, '.');
255:         return $Shell;
256:     }
257: 
258: /**
259:  * Parses command line options and extracts the directory paths from $params
260:  *
261:  * @param array $args Parameters to parse
262:  * @return void
263:  */
264:     public function parseParams($args) {
265:         $this->_parsePaths($args);
266: 
267:         $defaults = array(
268:             'app' => 'app',
269:             'root' => dirname(dirname(dirname(dirname(__FILE__)))),
270:             'working' => null,
271:             'webroot' => 'webroot'
272:         );
273:         $params = array_merge($defaults, array_intersect_key($this->params, $defaults));
274:         $isWin = false;
275:         foreach ($defaults as $default => $value) {
276:             if (strpos($params[$default], '\\') !== false) {
277:                 $isWin = true;
278:                 break;
279:             }
280:         }
281:         $params = str_replace('\\', '/', $params);
282: 
283:         if (isset($params['working'])) {
284:             $params['working'] = trim($params['working']);
285:         }
286: 
287:         if (!empty($params['working']) && (!isset($this->args[0]) || isset($this->args[0]) && $this->args[0][0] !== '.')) {
288:             if ($params['working'][0] === '.') {
289:                 $params['working'] = realpath($params['working']);
290:             }
291:             if (empty($this->params['app']) && $params['working'] != $params['root']) {
292:                 $params['root'] = dirname($params['working']);
293:                 $params['app'] = basename($params['working']);
294:             } else {
295:                 $params['root'] = $params['working'];
296:             }
297:         }
298: 
299:         if ($params['app'][0] === '/' || preg_match('/([a-z])(:)/i', $params['app'], $matches)) {
300:             $params['root'] = dirname($params['app']);
301:         } elseif (strpos($params['app'], '/')) {
302:             $params['root'] .= '/' . dirname($params['app']);
303:         }
304: 
305:         $params['app'] = basename($params['app']);
306:         $params['working'] = rtrim($params['root'], '/');
307:         if (!$isWin || !preg_match('/^[A-Z]:$/i', $params['app'])) {
308:             $params['working'] .= '/' . $params['app'];
309:         }
310: 
311:         if (!empty($matches[0]) || !empty($isWin)) {
312:             $params = str_replace('/', '\\', $params);
313:         }
314: 
315:         $this->params = array_merge($this->params, $params);
316:     }
317: 
318: /**
319:  * Parses out the paths from from the argv
320:  *
321:  * @param array $args
322:  * @return void
323:  */
324:     protected function _parsePaths($args) {
325:         $parsed = array();
326:         $keys = array('-working', '--working', '-app', '--app', '-root', '--root');
327:         foreach ($keys as $key) {
328:             while (($index = array_search($key, $args)) !== false) {
329:                 $keyname = str_replace('-', '', $key);
330:                 $valueIndex = $index + 1;
331:                 $parsed[$keyname] = $args[$valueIndex];
332:                 array_splice($args, $index, 2);
333:             }
334:         }
335:         $this->args = $args;
336:         $this->params = $parsed;
337:     }
338: 
339: /**
340:  * Removes first argument and shifts other arguments up
341:  *
342:  * @return mixed Null if there are no arguments otherwise the shifted argument
343:  */
344:     public function shiftArgs() {
345:         return array_shift($this->args);
346:     }
347: 
348: /**
349:  * Shows console help. Performs an internal dispatch to the CommandList Shell
350:  *
351:  * @return void
352:  */
353:     public function help() {
354:         $this->args = array_merge(array('command_list'), $this->args);
355:         $this->dispatch();
356:     }
357: 
358: /**
359:  * Stop execution of the current script
360:  *
361:  * @param integer|string $status see http://php.net/exit for values
362:  * @return void
363:  */
364:     protected function _stop($status = 0) {
365:         exit($status);
366:     }
367: 
368: }
369: