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