PEAR
[ class tree: PEAR ] [ index: PEAR ] [ all elements ]

Source for file Postinstallscript.php

Documentation is available at Postinstallscript.php

  1. <?php
  2. /**
  3.  * <tasks:postinstallscript>
  4.  *
  5.  * PHP versions 4 and 5
  6.  *
  7.  * @category   pear
  8.  * @package    PEAR
  9.  * @author     Greg Beaver <cellog@php.net>
  10.  * @copyright  1997-2009 The Authors
  11.  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  12.  * @version    CVS: $Id: Postinstallscript.php 313023 2011-07-06 19:17:11Z dufuz $
  13.  * @link       http://pear.php.net/package/PEAR
  14.  * @since      File available since Release 1.4.0a1
  15.  */
  16. /**
  17.  * Base class
  18.  */
  19. require_once 'PEAR/Task/Common.php';
  20. /**
  21.  * Implements the postinstallscript file task.
  22.  *
  23.  * Note that post-install scripts are handled separately from installation, by the
  24.  * "pear run-scripts" command
  25.  * @category   pear
  26.  * @package    PEAR
  27.  * @author     Greg Beaver <cellog@php.net>
  28.  * @copyright  1997-2009 The Authors
  29.  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  30.  * @version    Release: 1.9.4
  31.  * @link       http://pear.php.net/package/PEAR
  32.  * @since      Class available since Release 1.4.0a1
  33.  */
  34. {
  35.     var $type = 'script';
  36.     var $_class;
  37.     var $_params;
  38.     var $_obj;
  39.     /**
  40.      *
  41.      * @var PEAR_PackageFile_v2 
  42.      */
  43.     var $_pkg;
  44.     var $_contents;
  45.     var $phase = PEAR_TASK_INSTALL;
  46.  
  47.     /**
  48.      * Validate the raw xml at parsing-time.
  49.      *
  50.      * This also attempts to validate the script to make sure it meets the criteria
  51.      * for a post-install script
  52.      * @param PEAR_PackageFile_v2 
  53.      * @param array The XML contents of the <postinstallscript> tag
  54.      * @param PEAR_Config 
  55.      * @param array the entire parsed <file> tag
  56.      * @static
  57.      */
  58.     function validateXml($pkg$xml$config$fileXml)
  59.     {
  60.         if ($fileXml['role'!= 'php'{
  61.             return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  62.             $fileXml['name''" must be role="php"');
  63.         }
  64.         $file $pkg->getFileContents($fileXml['name']);
  65.         if (PEAR::isError($file)) {
  66.             PEAR::popErrorHandling();
  67.             return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  68.                 $fileXml['name''" is not valid: ' .
  69.                 $file->getMessage());
  70.         elseif ($file === null{
  71.             return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  72.                 $fileXml['name''" could not be retrieved for processing!');
  73.         else {
  74.             $analysis $pkg->analyzeSourceCode($filetrue);
  75.             if (!$analysis{
  76.                 PEAR::popErrorHandling();
  77.                 $warnings '';
  78.                 foreach ($pkg->getValidationWarnings(as $warn{
  79.                     $warnings .= $warn['message'"\n";
  80.                 }
  81.                 return array(PEAR_TASK_ERROR_INVALID'Analysis of post-install script "' .
  82.                     $fileXml['name''" failed: ' $warnings);
  83.             }
  84.             if (count($analysis['declared_classes']!= 1{
  85.                 PEAR::popErrorHandling();
  86.                 return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  87.                     $fileXml['name''" must declare exactly 1 class');
  88.             }
  89.             $class $analysis['declared_classes'][0];
  90.             if ($class != str_replace(array('/''.php')array('_'''),
  91.                   $fileXml['name']'_postinstall'{
  92.                 PEAR::popErrorHandling();
  93.                 return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  94.                     $fileXml['name''" class "' $class '" must be named "' .
  95.                     str_replace(array('/''.php')array('_'''),
  96.                     $fileXml['name']'_postinstall"');
  97.             }
  98.             if (!isset($analysis['declared_methods'][$class])) {
  99.                 PEAR::popErrorHandling();
  100.                 return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  101.                     $fileXml['name''" must declare methods init() and run()');
  102.             }
  103.             $methods = array('init' => 0'run' => 1);
  104.             foreach ($analysis['declared_methods'][$classas $method{
  105.                 if (isset($methods[$method])) {
  106.                     unset($methods[$method]);
  107.                 }
  108.             }
  109.             if (count($methods)) {
  110.                 PEAR::popErrorHandling();
  111.                 return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  112.                     $fileXml['name''" must declare methods init() and run()');
  113.             }
  114.         }
  115.         PEAR::popErrorHandling();
  116.         $definedparams = array();
  117.         $tasksNamespace $pkg->getTasksNs(':';
  118.         if (!isset($xml[$tasksNamespace 'paramgroup']&& isset($xml['paramgroup'])) {
  119.             // in order to support the older betas, which did not expect internal tags
  120.             // to also use the namespace
  121.             $tasksNamespace '';
  122.         }
  123.         if (isset($xml[$tasksNamespace 'paramgroup'])) {
  124.             $params $xml[$tasksNamespace 'paramgroup'];
  125.             if (!is_array($params|| !isset($params[0])) {
  126.                 $params = array($params);
  127.             }
  128.             foreach ($params as $param{
  129.                 if (!isset($param[$tasksNamespace 'id'])) {
  130.                     return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  131.                         $fileXml['name''" <paramgroup> must have ' .
  132.                         'an ' $tasksNamespace 'id> tag');
  133.                 }
  134.                 if (isset($param[$tasksNamespace 'name'])) {
  135.                     if (!in_array($param[$tasksNamespace 'name']$definedparams)) {
  136.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  137.                             $fileXml['name''" ' $tasksNamespace .
  138.                             'paramgroup> id "' $param[$tasksNamespace 'id'.
  139.                             '" parameter "' $param[$tasksNamespace 'name'.
  140.                             '" has not been previously defined');
  141.                     }
  142.                     if (!isset($param[$tasksNamespace 'conditiontype'])) {
  143.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  144.                             $fileXml['name''" ' $tasksNamespace .
  145.                             'paramgroup> id "' $param[$tasksNamespace 'id'.
  146.                             '" must have a ' $tasksNamespace .
  147.                             'conditiontype> tag containing either "=", ' .
  148.                             '"!=", or "preg_match"');
  149.                     }
  150.                     if (!in_array($param[$tasksNamespace 'conditiontype'],
  151.                           array('=''!=''preg_match'))) {
  152.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  153.                             $fileXml['name''" ' $tasksNamespace .
  154.                             'paramgroup> id "' $param[$tasksNamespace 'id'.
  155.                             '" must have a ' $tasksNamespace .
  156.                             'conditiontype> tag containing either "=", ' .
  157.                             '"!=", or "preg_match"');
  158.                     }
  159.                     if (!isset($param[$tasksNamespace 'value'])) {
  160.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  161.                             $fileXml['name''" ' $tasksNamespace .
  162.                             'paramgroup> id "' $param[$tasksNamespace 'id'.
  163.                             '" must have a ' $tasksNamespace .
  164.                             'value> tag containing expected parameter value');
  165.                     }
  166.                 }
  167.                 if (isset($param[$tasksNamespace 'instructions'])) {
  168.                     if (!is_string($param[$tasksNamespace 'instructions'])) {
  169.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  170.                             $fileXml['name''" ' $tasksNamespace .
  171.                             'paramgroup> id "' $param[$tasksNamespace 'id'.
  172.                             '" ' $tasksNamespace 'instructions> must be simple text');
  173.                     }
  174.                 }
  175.                 if (!isset($param[$tasksNamespace 'param'])) {
  176.                     continue; // <param> is no longer required
  177.                 }
  178.                 $subparams $param[$tasksNamespace 'param'];
  179.                 if (!is_array($subparams|| !isset($subparams[0])) {
  180.                     $subparams = array($subparams);
  181.                 }
  182.                 foreach ($subparams as $subparam{
  183.                     if (!isset($subparam[$tasksNamespace 'name'])) {
  184.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  185.                             $fileXml['name''" parameter for ' .
  186.                             $tasksNamespace 'paramgroup> id "' .
  187.                             $param[$tasksNamespace 'id''" must have ' .
  188.                             'a ' $tasksNamespace 'name> tag');
  189.                     }
  190.                     if (!preg_match('/[a-zA-Z0-9]+/',
  191.                           $subparam[$tasksNamespace 'name'])) {
  192.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  193.                             $fileXml['name''" parameter "' .
  194.                             $subparam[$tasksNamespace 'name'.
  195.                             '" for ' $tasksNamespace 'paramgroup> id "' .
  196.                             $param[$tasksNamespace 'id'.
  197.                             '" is not a valid name.  Must contain only alphanumeric characters');
  198.                     }
  199.                     if (!isset($subparam[$tasksNamespace 'prompt'])) {
  200.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  201.                             $fileXml['name''" parameter "' .
  202.                             $subparam[$tasksNamespace 'name'.
  203.                             '" for ' $tasksNamespace 'paramgroup> id "' .
  204.                             $param[$tasksNamespace 'id'.
  205.                             '" must have a ' $tasksNamespace 'prompt> tag');
  206.                     }
  207.                     if (!isset($subparam[$tasksNamespace 'type'])) {
  208.                         return array(PEAR_TASK_ERROR_INVALID'Post-install script "' .
  209.                             $fileXml['name''" parameter "' .
  210.                             $subparam[$tasksNamespace 'name'.
  211.                             '" for ' $tasksNamespace 'paramgroup> id "' .
  212.                             $param[$tasksNamespace 'id'.
  213.                             '" must have a ' $tasksNamespace 'type> tag');
  214.                     }
  215.                     $definedparams[$param[$tasksNamespace 'id''::' .
  216.                     $subparam[$tasksNamespace 'name'];
  217.                 }
  218.             }
  219.         }
  220.         return true;
  221.     }
  222.  
  223.     /**
  224.      * Initialize a task instance with the parameters
  225.      * @param array raw, parsed xml
  226.      * @param array attributes from the <file> tag containing this task
  227.      * @param string|nulllast installed version of this package, if any (useful for upgrades)
  228.      */
  229.     function init($xml$fileattribs$lastversion)
  230.     {
  231.         $this->_class str_replace('/''_'$fileattribs['name']);
  232.         $this->_filename $fileattribs['name'];
  233.         $this->_class str_replace ('.php'''$this->_class'_postinstall';
  234.         $this->_params $xml;
  235.         $this->_lastversion $lastversion;
  236.     }
  237.  
  238.     /**
  239.      * Strip the tasks: namespace from internal params
  240.      *
  241.      * @access private
  242.      */
  243.     function _stripNamespace($params = null)
  244.     {
  245.         if ($params === null{
  246.             $params = array();
  247.             if (!is_array($this->_params)) {
  248.                 return;
  249.             }
  250.             foreach ($this->_params as $i => $param{
  251.                 if (is_array($param)) {
  252.                     $param $this->_stripNamespace($param);
  253.                 }
  254.                 $params[str_replace($this->_pkg->getTasksNs(':'''$i)$param;
  255.             }
  256.             $this->_params $params;
  257.         else {
  258.             $newparams = array();
  259.             foreach ($params as $i => $param{
  260.                 if (is_array($param)) {
  261.                     $param $this->_stripNamespace($param);
  262.                 }
  263.                 $newparams[str_replace($this->_pkg->getTasksNs(':'''$i)$param;
  264.             }
  265.             return $newparams;
  266.         }
  267.     }
  268.  
  269.     /**
  270.      * Unlike other tasks, the installed file name is passed in instead of the file contents,
  271.      * because this task is handled post-installation
  272.      * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
  273.      * @param string file name
  274.      * @return bool|PEAR_Errorfalse to skip this file, PEAR_Error to fail
  275.      *          (use $this->throwError)
  276.      */
  277.     function startSession($pkg$contents)
  278.     {
  279.         if ($this->installphase != PEAR_TASK_INSTALL{
  280.             return false;
  281.         }
  282.         // remove the tasks: namespace if present
  283.         $this->_pkg $pkg;
  284.         $this->_stripNamespace();
  285.         $this->logger->log(0'Including external post-installation script "' .
  286.             $contents '" - any errors are in this script');
  287.         include_once $contents;
  288.         if (class_exists($this->_class)) {
  289.             $this->logger->log(0'Inclusion succeeded');
  290.         else {
  291.             return $this->throwError('init of post-install script class "' $this->_class
  292.                 . '" failed');
  293.         }
  294.         $this->_obj = new $this->_class;
  295.         $this->logger->log(1'running post-install script "' $this->_class '->init()"');
  296.         $res $this->_obj->init($this->config$pkg$this->_lastversion);
  297.         PEAR::popErrorHandling();
  298.         if ($res{
  299.             $this->logger->log(0'init succeeded');
  300.         else {
  301.             return $this->throwError('init of post-install script "' $this->_class .
  302.                 '->init()" failed');
  303.         }
  304.         $this->_contents $contents;
  305.         return true;
  306.     }
  307.  
  308.     /**
  309.      * No longer used
  310.      * @see PEAR_PackageFile_v2::runPostinstallScripts()
  311.      * @param array an array of tasks
  312.      * @param string install or upgrade
  313.      * @access protected
  314.      * @static
  315.      */
  316.     function run()
  317.     {
  318.     }
  319. }
  320. ?>

Documentation generated on Wed, 06 Jul 2011 23:31:08 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.