WebSVN - ant - Различия - Редакция 69 и 87 - /tags/0.2/lib/PEAR/Command/Install.php


<?php
/**
 * PEAR_Command_Install (install, upgrade, upgrade-all, uninstall, bundle, run-scripts commands)
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category   pear
 * @package    PEAR
 * @author     Stig Bakken <ssb@php.net>
 * @author     Greg Beaver <cellog@php.net>
 * @copyright  1997-2008 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: Install.php,v 1.141 2008/05/13 18:32:29 cellog Exp $
 * @link       http://pear.php.net/package/PEAR
 * @since      File available since Release 0.1
 */

/**
 * base class
 */
require_once 'PEAR/Command/Common.php';

/**
 * PEAR commands for installation or deinstallation/upgrading of
 * packages.
 *
 * @category   pear
 * @package    PEAR
 * @author     Stig Bakken <ssb@php.net>
 * @author     Greg Beaver <cellog@php.net>
 * @copyright  1997-2008 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.7.2
 * @link       http://pear.php.net/package/PEAR
 * @since      Class available since Release 0.1
 */
class PEAR_Command_Install extends PEAR_Command_Common
{
    // {{{ properties

    var $commands = array(
        'install' => array(
            'summary' => 'Install Package',
            'function' => 'doInstall',
            'shortcut' => 'i',
            'options' => array(
                'force' => array(
                    'shortopt' => 'f',
                    'doc' => 'will overwrite newer installed packages',
                    ),
                'loose' => array(
                    'shortopt' => 'l',
                    'doc' => 'do not check for recommended dependency version',
                    ),
                'nodeps' => array(
                    'shortopt' => 'n',
                    'doc' => 'ignore dependencies, install anyway',
                    ),
                'register-only' => array(
                    'shortopt' => 'r',
                    'doc' => 'do not install files, only register the package as installed',
                    ),
                'soft' => array(
                    'shortopt' => 's',
                    'doc' => 'soft install, fail silently, or upgrade if already installed',
                    ),
                'nobuild' => array(
                    'shortopt' => 'B',
                    'doc' => 'don\'t build C extensions',
                    ),
                'nocompress' => array(
                    'shortopt' => 'Z',
                    'doc' => 'request uncompressed files when downloading',
                    ),
                'installroot' => array(
                    'shortopt' => 'R',
                    'arg' => 'DIR',
                    'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
                    ),
                'packagingroot' => array(
                    'shortopt' => 'P',
                    'arg' => 'DIR',
                    'doc' => 'root directory used when packaging files, like RPM packaging',
                    ),
                'ignore-errors' => array(
                    'doc' => 'force install even if there were errors',
                    ),
                'alldeps' => array(
                    'shortopt' => 'a',
                    'doc' => 'install all required and optional dependencies',
                    ),
                'onlyreqdeps' => array(
                    'shortopt' => 'o',
                    'doc' => 'install all required dependencies',
                    ),
                'offline' => array(
                    'shortopt' => 'O',
                    'doc' => 'do not attempt to download any urls or contact channels',
                    ),
                'pretend' => array(
                    'shortopt' => 'p',
                    'doc' => 'Only list the packages that would be downloaded',
                    ),
                ),
            'doc' => '[channel/]<package> ...
Installs one or more PEAR packages.  You can specify a package to
install in four ways:

"Package-1.0.tgz" : installs from a local file

"http://example.com/Package-1.0.tgz" : installs from
anywhere on the net.

"package.xml" : installs the package described in
package.xml.  Useful for testing, or for wrapping a PEAR package in
another package manager such as RPM.

"Package[-version/state][.tar]" : queries your default channel\'s server
({config master_server}) and downloads the newest package with
the preferred quality/state ({config preferred_state}).

To retrieve Package version 1.1, use "Package-1.1," to retrieve
Package state beta, use "Package-beta."  To retrieve an uncompressed
file, append .tar (make sure there is no file by the same name first)

To download a package from another channel, prefix with the channel name like
"channel/Package"

More than one package may be specified at once.  It is ok to mix these
four ways of specifying packages.
'),
        'upgrade' => array(
            'summary' => 'Upgrade Package',
            'function' => 'doInstall',
            'shortcut' => 'up',
            'options' => array(
                'force' => array(
                    'shortopt' => 'f',
                    'doc' => 'overwrite newer installed packages',
                    ),
                'loose' => array(
                    'shortopt' => 'l',
                    'doc' => 'do not check for recommended dependency version',
                    ),
                'nodeps' => array(
                    'shortopt' => 'n',
                    'doc' => 'ignore dependencies, upgrade anyway',
                    ),
                'register-only' => array(
                    'shortopt' => 'r',
                    'doc' => 'do not install files, only register the package as upgraded',
                    ),
                'nobuild' => array(
                    'shortopt' => 'B',
                    'doc' => 'don\'t build C extensions',
                    ),
                'nocompress' => array(
                    'shortopt' => 'Z',
                    'doc' => 'request uncompressed files when downloading',
                    ),
                'installroot' => array(
                    'shortopt' => 'R',
                    'arg' => 'DIR',
                    'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
                    ),
                'ignore-errors' => array(
                    'doc' => 'force install even if there were errors',
                    ),
                'alldeps' => array(
                    'shortopt' => 'a',
                    'doc' => 'install all required and optional dependencies',
                    ),
                'onlyreqdeps' => array(
                    'shortopt' => 'o',
                    'doc' => 'install all required dependencies',
                    ),
                'offline' => array(
                    'shortopt' => 'O',
                    'doc' => 'do not attempt to download any urls or contact channels',
                    ),
                'pretend' => array(
                    'shortopt' => 'p',
                    'doc' => 'Only list the packages that would be downloaded',
                    ),
                ),
            'doc' => '<package> ...
Upgrades one or more PEAR packages.  See documentation for the
"install" command for ways to specify a package.

When upgrading, your package will be updated if the provided new
package has a higher version number (use the -f option if you need to
upgrade anyway).

More than one package may be specified at once.
'),
        'upgrade-all' => array(
            'summary' => 'Upgrade All Packages',
            'function' => 'doUpgradeAll',
            'shortcut' => 'ua',
            'options' => array(
                'nodeps' => array(
                    'shortopt' => 'n',
                    'doc' => 'ignore dependencies, upgrade anyway',
                    ),
                'register-only' => array(
                    'shortopt' => 'r',
                    'doc' => 'do not install files, only register the package as upgraded',
                    ),
                'nobuild' => array(
                    'shortopt' => 'B',
                    'doc' => 'don\'t build C extensions',
                    ),
                'nocompress' => array(
                    'shortopt' => 'Z',
                    'doc' => 'request uncompressed files when downloading',
                    ),
                'installroot' => array(
                    'shortopt' => 'R',
                    'arg' => 'DIR',
                    'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
                    ),
                'ignore-errors' => array(
                    'doc' => 'force install even if there were errors',
                    ),
                'loose' => array(
                    'doc' => 'do not check for recommended dependency version',
                    ),
                ),
            'doc' => '
Upgrades all packages that have a newer release available.  Upgrades are
done only if there is a release available of the state specified in
"preferred_state" (currently {config preferred_state}), or a state considered
more stable.
'),
        'uninstall' => array(
            'summary' => 'Un-install Package',
            'function' => 'doUninstall',
            'shortcut' => 'un',
            'options' => array(
                'nodeps' => array(
                    'shortopt' => 'n',
                    'doc' => 'ignore dependencies, uninstall anyway',
                    ),
                'register-only' => array(
                    'shortopt' => 'r',
                    'doc' => 'do not remove files, only register the packages as not installed',
                    ),
                'installroot' => array(
                    'shortopt' => 'R',
                    'arg' => 'DIR',
                    'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
                    ),
                'ignore-errors' => array(
                    'doc' => 'force install even if there were errors',
                    ),
                'offline' => array(
                    'shortopt' => 'O',
                    'doc' => 'do not attempt to uninstall remotely',
                    ),
                ),
            'doc' => '[channel/]<package> ...
Uninstalls one or more PEAR packages.  More than one package may be
specified at once.  Prefix with channel name to uninstall from a
channel not in your default channel ({config default_channel})
'),
        'bundle' => array(
            'summary' => 'Unpacks a Pecl Package',
            'function' => 'doBundle',
            'shortcut' => 'bun',
            'options' => array(
                'destination' => array(
                   'shortopt' => 'd',
                    'arg' => 'DIR',
                    'doc' => 'Optional destination directory for unpacking (defaults to current path or "ext" if exists)',
                    ),
                'force' => array(
                    'shortopt' => 'f',
                    'doc' => 'Force the unpacking even if there were errors in the package',
                ),
            ),
            'doc' => '<package>
Unpacks a Pecl Package into the selected location. It will download the
package if needed.
'),
        'run-scripts' => array(
            'summary' => 'Run Post-Install Scripts bundled with a package',
            'function' => 'doRunScripts',
            'shortcut' => 'rs',
            'options' => array(
            ),
            'doc' => '<package>
Run post-installation scripts in package <package>, if any exist.
'),
    );

    // }}}
    // {{{ constructor

    /**
     * PEAR_Command_Install constructor.
     *
     * @access public
     */
    function PEAR_Command_Install(&$ui, &$config)
    {
        parent::PEAR_Command_Common($ui, $config);
    }

    // }}}

    /**
     * For unit testing purposes
     */
    function &getDownloader(&$ui, $options, &$config)
    {
        if (!class_exists('PEAR_Downloader')) {
            require_once 'PEAR/Downloader.php';
        }
        $a = &new PEAR_Downloader($ui, $options, $config);
        return $a;
    }

    /**
     * For unit testing purposes
     */
    function &getInstaller(&$ui)
    {
        if (!class_exists('PEAR_Installer')) {
            require_once 'PEAR/Installer.php';
        }
        $a = &new PEAR_Installer($ui);
        return $a;
    }

    function enableExtension($binaries, $type)
    {
        if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
            return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
        }
        $ini = $this->_parseIni($phpini);
        if (PEAR::isError($ini)) {
            return $ini;
        }
        $line = 0;
        if ($type == 'extsrc' || $type == 'extbin') {
            $search = 'extensions';
            $enable = 'extension';
        } else {
            $search = 'zend_extensions';
            ob_start();
            phpinfo(INFO_GENERAL);
            $info = ob_get_contents();
            ob_end_clean();
            $debug = function_exists('leak') ? '_debug' : '';
            $ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
            $enable = 'zend_extension' . $debug . $ts;
        }
        foreach ($ini[$search] as $line => $extension) {
            if (in_array($extension, $binaries, true) || in_array(
                  $ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
                // already enabled - assume if one is, all are
                return true;
            }
        }
        if ($line) {
            $newini = array_slice($ini['all'], 0, $line);
        } else {
            $newini = array();
        }
        foreach ($binaries as $binary) {
            if ($ini['extension_dir']) {
                $binary = basename($binary);
            }
            $newini[] = $enable . '="' . $binary . '"' . (OS_UNIX ? "\n" : "\r\n");
        }
        $newini = array_merge($newini, array_slice($ini['all'], $line));
        $fp = @fopen($phpini, 'wb');
        if (!$fp) {
            return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
        }
        foreach ($newini as $line) {
            fwrite($fp, $line);
        }
        fclose($fp);
        return true;
    }

    function disableExtension($binaries, $type)
    {
        if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
            return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
        }
        $ini = $this->_parseIni($phpini);
        if (PEAR::isError($ini)) {
            return $ini;
        }
        $line = 0;
        if ($type == 'extsrc' || $type == 'extbin') {
            $search = 'extensions';
            $enable = 'extension';
        } else {
            $search = 'zend_extensions';
            ob_start();
            phpinfo(INFO_GENERAL);
            $info = ob_get_contents();
            ob_end_clean();
            $debug = function_exists('leak') ? '_debug' : '';
            $ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
            $enable = 'zend_extension' . $debug . $ts;
        }
        $found = false;
        foreach ($ini[$search] as $line => $extension) {
            if (in_array($extension, $binaries, true) || in_array(
                  $ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
                $found = true;
                break;
            }
        }
        if (!$found) {
            // not enabled
            return true;
        }
        $fp = @fopen($phpini, 'wb');
        if (!$fp) {
            return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
        }
        if ($line) {
            $newini = array_slice($ini['all'], 0, $line);
            // delete the enable line
            $newini = array_merge($newini, array_slice($ini['all'], $line + 1));
        } else {
            $newini = array_slice($ini['all'], 1);
        }
        foreach ($newini as $line) {
            fwrite($fp, $line);
        }
        fclose($fp);
        return true;
    }

    function _parseIni($filename)
    {
        if (file_exists($filename)) {
            if (filesize($filename) > 300000) {
                return PEAR::raiseError('php.ini "' . $filename . '" is too large, aborting');
            }
            ob_start();
            phpinfo(INFO_GENERAL);
            $info = ob_get_contents();
            ob_end_clean();
            $debug = function_exists('leak') ? '_debug' : '';
            $ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
            $zend_extension_line = 'zend_extension' . $debug . $ts;
            $all = @file($filename);
            if (!$all) {
                return PEAR::raiseError('php.ini "' . $filename .'" could not be read');
            }
            $zend_extensions = $extensions = array();
            // assume this is right, but pull from the php.ini if it is found
            $extension_dir = ini_get('extension_dir');
            foreach ($all as $linenum => $line) {
                $line = trim($line);
                if (!$line) {
                    continue;
                }
                if ($line[0] == ';') {
                    continue;
                }
                if (strtolower(substr($line, 0, 13)) == 'extension_dir') {
                    $line = trim(substr($line, 13));
                    if ($line[0] == '=') {
                        $x = trim(substr($line, 1));
                        $x = explode(';', $x);
                        $extension_dir = str_replace('"', '', array_shift($x));
                        continue;
                    }
                }
                if (strtolower(substr($line, 0, 9)) == 'extension') {
                    $line = trim(substr($line, 9));
                    if ($line[0] == '=') {
                        $x = trim(substr($line, 1));
                        $x = explode(';', $x);
                        $extensions[$linenum] = str_replace('"', '', array_shift($x));
                        continue;
                    }
                }
                if (strtolower(substr($line, 0, strlen($zend_extension_line))) ==
                      $zend_extension_line) {
                    $line = trim(substr($line, strlen($zend_extension_line)));
                    if ($line[0] == '=') {
                        $x = trim(substr($line, 1));
                        $x = explode(';', $x);
                        $zend_extensions[$linenum] = str_replace('"', '', array_shift($x));
                        continue;
                    }
                }
            }
            return array(
                'extensions' => $extensions,
                'zend_extensions' => $zend_extensions,
                'extension_dir' => $extension_dir,
                'all' => $all,
            );
        } else {
            return PEAR::raiseError('php.ini "' . $filename . '" does not exist');
        }
    }

    // {{{ doInstall()

    function doInstall($command, $options, $params)
    {
        if (!class_exists('PEAR_PackageFile')) {
            require_once 'PEAR/PackageFile.php';
        }
        if (empty($this->installer)) {
            $this->installer = &$this->getInstaller($this->ui);
        }
        if ($command == 'upgrade' || $command == 'upgrade-all') {
            $options['upgrade'] = true;
        } else {
            $packages = $params;
        }
        if (isset($options['installroot']) && isset($options['packagingroot'])) {
            return $this->raiseError('ERROR: cannot use both --installroot and --packagingroot');
        }
        $reg = &$this->config->getRegistry();
        $instreg = &$reg; // instreg used to check if package is installed
        if (isset($options['packagingroot']) && !isset($options['upgrade'])) {
            $packrootphp_dir = $this->installer->_prependPath(
                $this->config->get('php_dir', null, 'pear.php.net'),
                $options['packagingroot']);
            $instreg = new PEAR_Registry($packrootphp_dir); // other instreg!

            if ($this->config->get('verbose') > 2) {
                $this->ui->outputData('using package root: ' . $options['packagingroot']);
            }
        }
        $abstractpackages = array();
        $otherpackages = array();
        // parse params
        PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
        foreach($params as $param) {
            if (strpos($param, 'http://') === 0) {
                $otherpackages[] = $param;
                continue;
            }
            if (strpos($param, 'channel://') === false && @file_exists($param)) {
                if (isset($options['force'])) {
                    $otherpackages[] = $param;
                    continue;
                }
                $pkg = new PEAR_PackageFile($this->config);
                $pf = $pkg->fromAnyFile($param, PEAR_VALIDATE_DOWNLOADING);
                if (PEAR::isError($pf)) {
                    $otherpackages[] = $param;
                    continue;
                }
                if ($reg->packageExists($pf->getPackage(), $pf->getChannel()) &&
                      version_compare($pf->getVersion(),
                      $reg->packageInfo($pf->getPackage(), 'version', $pf->getChannel()),
                      '<=')) {
                    if ($this->config->get('verbose')) {
                        $this->ui->outputData('Ignoring installed package ' .
                            $reg->parsedPackageNameToString(
                            array('package' => $pf->getPackage(),
                                  'channel' => $pf->getChannel()), true));
                    }
                    continue;
                }
                $otherpackages[] = $param;
                continue;
            }
            $e = $reg->parsePackageName($param, $this->config->get('default_channel'));
            if (PEAR::isError($e)) {
                $otherpackages[] = $param;
            } else {
                $abstractpackages[] = $e;
            }
        }
        PEAR::staticPopErrorHandling();

        // if there are any local package .tgz or remote static url, we can't
        // filter.  The filter only works for abstract packages
        if (count($abstractpackages) && !isset($options['force'])) {
            // when not being forced, only do necessary upgrades/installs
            if (isset($options['upgrade'])) {
                $abstractpackages = $this->_filterUptodatePackages($abstractpackages,
                    $command);
            } else {
                foreach ($abstractpackages as $i => $package) {
                    if (isset($package['group'])) {
                        // do not filter out install groups
                        continue;
                    }
                    if ($instreg->packageExists($package['package'], $package['channel'])) {
                        if ($this->config->get('verbose')) {
                            $this->ui->outputData('Ignoring installed package ' .
                                $reg->parsedPackageNameToString($package, true));
                        }
                        unset($abstractpackages[$i]);
                    }
                }
            }
            $abstractpackages =
                array_map(array($reg, 'parsedPackageNameToString'), $abstractpackages);
        } elseif (count($abstractpackages)) {
            $abstractpackages =
                array_map(array($reg, 'parsedPackageNameToString'), $abstractpackages);
        }


        $packages = array_merge($abstractpackages, $otherpackages);
        if (!count($packages)) {
            $this->ui->outputData('Nothing to ' . $command);
            return true;
        }

        $this->downloader = &$this->getDownloader($this->ui, $options, $this->config);
        $errors = array();
        $binaries = array();
        $downloaded = array();
        $downloaded = &$this->downloader->download($packages);
        if (PEAR::isError($downloaded)) {
            return $this->raiseError($downloaded);
        }
        $errors = $this->downloader->getErrorMsgs();
        if (count($errors)) {
            $err = array();
            $err['data'] = array();
            foreach ($errors as $error) {
                $err['data'][] = array($error);
            }
            $err['headline'] = 'Install Errors';
            $this->ui->outputData($err);
            if (!count($downloaded)) {
                return $this->raiseError("$command failed");
            }
        }
        $data = array(
            'headline' => 'Packages that would be Installed'
        );
        if (isset($options['pretend'])) {
            foreach ($downloaded as $package) {
                $data['data'][] = array($reg->parsedPackageNameToString($package->getParsedPackage()));
            }
            $this->ui->outputData($data, 'pretend');
            return true;
        }
        $this->installer->setOptions($options);
        $this->installer->sortPackagesForInstall($downloaded);
        if (PEAR::isError($err = $this->installer->setDownloadedPackages($downloaded))) {
            $this->raiseError($err->getMessage());
            return true;
        }
        $extrainfo = array();
        $binaries = array();
        foreach ($downloaded as $param) {
            PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
            $info = $this->installer->install($param, $options);
            PEAR::staticPopErrorHandling();
            if (PEAR::isError($info)) {
                $oldinfo = $info;
                $pkg = &$param->getPackageFile();
                if ($info->getCode() != PEAR_INSTALLER_NOBINARY) {
                    if (!($info = $pkg->installBinary($this->installer))) {
                        $this->ui->outputData('ERROR: ' .$oldinfo->getMessage());
                        continue;
                    }
                    // we just installed a different package than requested,
                    // let's change the param and info so that the rest of this works
                    $param = $info[0];
                    $info = $info[1];
                }
            }
            if (is_array($info)) {
                if ($param->getPackageType() == 'extsrc' ||
                      $param->getPackageType() == 'extbin' ||
                      $param->getPackageType() == 'zendextsrc' ||
                      $param->getPackageType() == 'zendextbin') {
                    $pkg = &$param->getPackageFile();
                    if ($instbin = $pkg->getInstalledBinary()) {
                        $instpkg = &$instreg->getPackage($instbin, $pkg->getChannel());
                    } else {
                        $instpkg = &$instreg->getPackage($pkg->getPackage(), $pkg->getChannel());
                    }

                    foreach ($instpkg->getFilelist() as $name => $atts) {
                        $pinfo = pathinfo($atts['installed_as']);
                        if (!isset($pinfo['extension']) ||
                              in_array($pinfo['extension'], array('c', 'h'))) {
                            continue; // make sure we don't match php_blah.h
                        }
                        if ((strpos($pinfo['basename'], 'php_') === 0 &&
                              $pinfo['extension'] == 'dll') ||
                              // most unices
                              $pinfo['extension'] == 'so' ||
                              // hp-ux
                              $pinfo['extension'] == 'sl') {
                            $binaries[] = array($atts['installed_as'], $pinfo);
                            break;
                        }
                    }
                    if (count($binaries)) {
                        foreach ($binaries as $pinfo) {
                            PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
                            $ret = $this->enableExtension(array($pinfo[0]), $param->getPackageType());
                            PEAR::staticPopErrorHandling();
                            if (PEAR::isError($ret)) {
                                $extrainfo[] = $ret->getMessage();
                                if ($param->getPackageType() == 'extsrc' ||
                                      $param->getPackageType() == 'extbin') {
                                    $exttype = 'extension';
                                } else {
                                    ob_start();
                                    phpinfo(INFO_GENERAL);
                                    $info = ob_get_contents();
                                    ob_end_clean();
                                    $debug = function_exists('leak') ? '_debug' : '';
                                    $ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
                                    $exttype = 'zend_extension' . $debug . $ts;
                                }
                                $extrainfo[] = 'You should add "' . $exttype . '=' .
                                    $pinfo[1]['basename'] . '" to php.ini';
                            } else {
                                $extrainfo[] = 'Extension ' . $instpkg->getProvidesExtension() .
                                    ' enabled in php.ini';
                            }
                        }
                    }
                }
                if ($this->config->get('verbose') > 0) {
                    $channel = $param->getChannel();
                    $label = $reg->parsedPackageNameToString(
                        array(
                            'channel' => $channel,
                            'package' => $param->getPackage(),
                            'version' => $param->getVersion(),
                        ));
                    $out = array('data' => "$command ok: $label");
                    if (isset($info['release_warnings'])) {
                        $out['release_warnings'] = $info['release_warnings'];
                    }
                    $this->ui->outputData($out, $command);
                    if (!isset($options['register-only']) && !isset($options['offline'])) {
                        if ($this->config->isDefinedLayer('ftp')) {
                            PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
                            $info = $this->installer->ftpInstall($param);
                            PEAR::staticPopErrorHandling();
                            if (PEAR::isError($info)) {
                                $this->ui->outputData($info->getMessage());
                                $this->ui->outputData("remote install failed: $label");
                            } else {
                                $this->ui->outputData("remote install ok: $label");
                            }
                        }
                    }
                }
                $deps = $param->getDeps();
                if ($deps) {
                    if (isset($deps['group'])) {
                        $groups = $deps['group'];
                        if (!isset($groups[0])) {
                            $groups = array($groups);
                        }
                        foreach ($groups as $group) {
                            if ($group['attribs']['name'] == 'default') {
                                // default group is always installed, unless the user
                                // explicitly chooses to install another group
                                continue;
                            }
                            $extrainfo[] = $param->getPackage() . ': Optional feature ' .
                                $group['attribs']['name'] . ' available (' .
                                $group['attribs']['hint'] . ')';
                        }
                        $extrainfo[] = $param->getPackage() .
                            ': To install optional features use "pear install ' .
                            $reg->parsedPackageNameToString(
                                array('package' => $param->getPackage(),
                                      'channel' => $param->getChannel()), true) .
                                  '#featurename"';
                    }
                }
                $pkg = &$instreg->getPackage($param->getPackage(), $param->getChannel());
                // $pkg may be NULL if install is a 'fake' install via --packagingroot
                if (is_object($pkg)) {
                    $pkg->setConfig($this->config);
                    if ($list = $pkg->listPostinstallScripts()) {
                        $pn = $reg->parsedPackageNameToString(array('channel' =>
                           $param->getChannel(), 'package' => $param->getPackage()), true);
                        $extrainfo[] = $pn . ' has post-install scripts:';
                        foreach ($list as $file) {
                            $extrainfo[] = $file;
                        }
                        $extrainfo[] = $param->getPackage() .
                            ': Use "pear run-scripts ' . $pn . '" to finish setup.';
                        $extrainfo[] = 'DO NOT RUN SCRIPTS FROM UNTRUSTED SOURCES';
                    }
                }
            } else {
                return $this->raiseError("$command failed");
            }
        }
        if (count($extrainfo)) {
            foreach ($extrainfo as $info) {
                $this->ui->outputData($info);
            }
        }
        return true;
    }

    // }}}
    // {{{ doUpgradeAll()

    function doUpgradeAll($command, $options, $params)
    {
        $reg = &$this->config->getRegistry();
        $toUpgrade = array();
        foreach ($reg->listChannels() as $channel) {
            if ($channel == '__uri') {
                continue;
            }

            // parse name with channel
            foreach ($reg->listPackages($channel) as $name) {
                $toUpgrade[] = $reg->parsedPackageNameToString(array(
                        'channel' => $channel,
                        'package' => $name
                    ));
            }
        }

        $err = $this->doInstall('upgrade-all', $options, $toUpgrade);
        if (PEAR::isError($err)) {
            $this->ui->outputData($err->getMessage(), $command);
        }
   }

    // }}}
    // {{{ doUninstall()

    function doUninstall($command, $options, $params)
    {
        if (empty($this->installer)) {
            $this->installer = &$this->getInstaller($this->ui);
        }
        if (isset($options['remoteconfig'])) {
            $e = $this->config->readFTPConfigFile($options['remoteconfig']);
            if (!PEAR::isError($e)) {
                $this->installer->setConfig($this->config);
            }
        }
        if (sizeof($params) < 1) {
            return $this->raiseError("Please supply the package(s) you want to uninstall");
        }
        $reg = &$this->config->getRegistry();
        $newparams = array();
        $binaries = array();
        $badparams = array();
        foreach ($params as $pkg) {
            $channel = $this->config->get('default_channel');
            PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
            $parsed = $reg->parsePackageName($pkg, $channel);
            PEAR::staticPopErrorHandling();
            if (!$parsed || PEAR::isError($parsed)) {
                $badparams[] = $pkg;
                continue;
            }
            $package = $parsed['package'];
            $channel = $parsed['channel'];
            $info = &$reg->getPackage($package, $channel);
            if ($info === null &&
                 ($channel == 'pear.php.net' || $channel == 'pecl.php.net')) {
                // make sure this isn't a package that has flipped from pear to pecl but
                // used a package.xml 1.0
                $testc = ($channel == 'pear.php.net') ? 'pecl.php.net' : 'pear.php.net';
                $info = &$reg->getPackage($package, $testc);
                if ($info !== null) {
                    $channel = $testc;
                }
            }
            if ($info === null) {
                $badparams[] = $pkg;
            } else {
                $newparams[] = &$info;
                // check for binary packages (this is an alias for those packages if so)
                if ($installedbinary = $info->getInstalledBinary()) {
                    $this->ui->log('adding binary package ' .
                        $reg->parsedPackageNameToString(array('channel' => $channel,
                            'package' => $installedbinary), true));
                    $newparams[] = &$reg->getPackage($installedbinary, $channel);
                }
                // add the contents of a dependency group to the list of installed packages
                if (isset($parsed['group'])) {
                    $group = $info->getDependencyGroup($parsed['group']);
                    if ($group) {
                        $installed = $reg->getInstalledGroup($group);
                        if ($installed) {
                            foreach ($installed as $i => $p) {
                                $newparams[] = &$installed[$i];
                            }
                        }
                    }
                }
            }
        }
        $err = $this->installer->sortPackagesForUninstall($newparams);
        if (PEAR::isError($err)) {
            $this->ui->outputData($err->getMessage(), $command);
            return true;
        }
        $params = $newparams;
        // twist this to use it to check on whether dependent packages are also being uninstalled
        // for circular dependencies like subpackages
        $this->installer->setUninstallPackages($newparams);
        $params = array_merge($params, $badparams);
        $binaries = array();
        foreach ($params as $pkg) {
            $this->installer->pushErrorHandling(PEAR_ERROR_RETURN);
            if ($err = $this->installer->uninstall($pkg, $options)) {
                $this->installer->popErrorHandling();
                if (PEAR::isError($err)) {
                    $this->ui->outputData($err->getMessage(), $command);
                    continue;
                }
                if ($pkg->getPackageType() == 'extsrc' ||
                      $pkg->getPackageType() == 'extbin' ||
                      $pkg->getPackageType() == 'zendextsrc' ||
                      $pkg->getPackageType() == 'zendextbin') {
                    if ($instbin = $pkg->getInstalledBinary()) {
                        continue; // this will be uninstalled later
                    }

                    foreach ($pkg->getFilelist() as $name => $atts) {
                        $pinfo = pathinfo($atts['installed_as']);
                        if (!isset($pinfo['extension']) ||
                              in_array($pinfo['extension'], array('c', 'h'))) {
                            continue; // make sure we don't match php_blah.h
                        }
                        if ((strpos($pinfo['basename'], 'php_') === 0 &&
                              $pinfo['extension'] == 'dll') ||
                              // most unices
                              $pinfo['extension'] == 'so' ||
                              // hp-ux
                              $pinfo['extension'] == 'sl') {
                            $binaries[] = array($atts['installed_as'], $pinfo);
                            break;
                        }
                    }
                    if (count($binaries)) {
                        foreach ($binaries as $pinfo) {
                            PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
                            $ret = $this->disableExtension(array($pinfo[0]), $pkg->getPackageType());
                            PEAR::staticPopErrorHandling();
                            if (PEAR::isError($ret)) {
                                $extrainfo[] = $ret->getMessage();
                                if ($pkg->getPackageType() == 'extsrc' ||
                                      $pkg->getPackageType() == 'extbin') {
                                    $exttype = 'extension';
                                } else {
                                    ob_start();
                                    phpinfo(INFO_GENERAL);
                                    $info = ob_get_contents();
                                    ob_end_clean();
                                    $debug = function_exists('leak') ? '_debug' : '';
                                    $ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
                                    $exttype = 'zend_extension' . $debug . $ts;
                                }
                                $this->ui->outputData('Unable to remove "' . $exttype . '=' .
                                    $pinfo[1]['basename'] . '" from php.ini', $command);
                            } else {
                                $this->ui->outputData('Extension ' . $pkg->getProvidesExtension() .
                                    ' disabled in php.ini', $command);
                            }
                        }
                    }
                }
                $savepkg = $pkg;
                if ($this->config->get('verbose') > 0) {
                    if (is_object($pkg)) {
                        $pkg = $reg->parsedPackageNameToString($pkg);
                    }
                    $this->ui->outputData("uninstall ok: $pkg", $command);
                }
                if (!isset($options['offline']) && is_object($savepkg) &&
                      defined('PEAR_REMOTEINSTALL_OK')) {
                    if ($this->config->isDefinedLayer('ftp')) {
                        $this->installer->pushErrorHandling(PEAR_ERROR_RETURN);
                        $info = $this->installer->ftpUninstall($savepkg);
                        $this->installer->popErrorHandling();
                        if (PEAR::isError($info)) {
                            $this->ui->outputData($info->getMessage());
                            $this->ui->outputData("remote uninstall failed: $pkg");
                        } else {
                            $this->ui->outputData("remote uninstall ok: $pkg");
                        }
                    }
                }
            } else {
                $this->installer->popErrorHandling();
                if (is_object($pkg)) {
                    $pkg = $reg->parsedPackageNameToString($pkg);
                }
                return $this->raiseError("uninstall failed: $pkg");
            }
        }
        return true;
    }

    // }}}


    // }}}
    // {{{ doBundle()
    /*
    (cox) It just downloads and untars the package, does not do
            any check that the PEAR_Installer::_installFile() does.
    */

    function doBundle($command, $options, $params)
    {
        $downloader = &$this->getDownloader($this->ui, array('force' => true, 'nodeps' => true,
            'soft' => true, 'downloadonly' => true), $this->config);
        $reg = &$this->config->getRegistry();
        if (sizeof($params) < 1) {
            return $this->raiseError("Please supply the package you want to bundle");
        }

        if (isset($options['destination'])) {
            if (!is_dir($options['destination'])) {
                System::mkdir('-p ' . $options['destination']);
            }
            $dest = realpath($options['destination']);
        } else {
            $pwd = getcwd();
            if (is_dir($pwd . DIRECTORY_SEPARATOR . 'ext')) {
                $dest = $pwd . DIRECTORY_SEPARATOR . 'ext';
            } else {
                $dest = $pwd;
            }
        }
        PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
        $err = $downloader->setDownloadDir($dest);
        PEAR::staticPopErrorHandling();
        if (PEAR::isError($err)) {
            return PEAR::raiseError('download directory "' . $dest .
                '" is not writeable.');
        }
        $result = &$downloader->download(array($params[0]));
        if (PEAR::isError($result)) {
            return $result;
        }
        if (!isset($result[0])) {
            return $this->raiseError('unable to unpack ' . $params[0]);
        }
        $pkgfile = &$result[0]->getPackageFile();
        $pkgname = $pkgfile->getName();
        $pkgversion = $pkgfile->getVersion();

        // Unpacking -------------------------------------------------
        $dest .= DIRECTORY_SEPARATOR . $pkgname;
        $orig = $pkgname . '-' . $pkgversion;

        $tar = &new Archive_Tar($pkgfile->getArchiveFile());
        if (!$tar->extractModify($dest, $orig)) {
            return $this->raiseError('unable to unpack ' . $pkgfile->getArchiveFile());
        }
        $this->ui->outputData("Package ready at '$dest'");
    // }}}
    }

    // }}}

    function doRunScripts($command, $options, $params)
    {
        if (!isset($params[0])) {
            return $this->raiseError('run-scripts expects 1 parameter: a package name');
        }
        $reg = &$this->config->getRegistry();
        PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
        $parsed = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
        PEAR::staticPopErrorHandling();
        if (PEAR::isError($parsed)) {
            return $this->raiseError($parsed);
        }
        $package = &$reg->getPackage($parsed['package'], $parsed['channel']);
        if (is_object($package)) {
            $package->setConfig($this->config);
            $package->runPostinstallScripts();
        } else {
            return $this->raiseError('Could not retrieve package "' . $params[0] . '" from registry');
        }
        $this->ui->outputData('Install scripts complete', $command);
        return true;
    }

    /**
     * Given a list of packages, filter out those ones that are already up to date
     *
     * @param $packages: packages, in parsed array format !
     * @return list of packages that can be upgraded
     */
    function _filterUptodatePackages($packages, $command)
    {
        $reg = &$this->config->getRegistry();
        $latestReleases = array();

        $ret = array();
        foreach($packages as $package) {
            if (isset($package['group'])) {
                $ret[] = $package;
                continue;
            }
            $channel = $package['channel'];
            $name = $package['package'];

            if (!$reg->packageExists($name, $channel)) {
                $ret[] = $package;
                continue;
            }
            if (!isset($latestReleases[$channel])) {
                // fill in cache for this channel
                $chan = &$reg->getChannel($channel);
                if (PEAR::isError($chan)) {
                    return $this->raiseError($chan);
                }
                if ($chan->supportsREST($this->config->get('preferred_mirror',
                                                           null, $channel)) &&
                      $base = $chan->getBaseURL('REST1.0',
                                                $this->config->get('preferred_mirror',
                                                                   null, $channel)))
                {
                    $dorest = true;
                } else {
                    $dorest = false;
                    $remote = &$this->config->getRemote($this->config);
                }
                PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
                if ($dorest) {
                    $rest = &$this->config->getREST('1.0', array());
                    $installed = array_flip($reg->listPackages($channel));
                    $latest = $rest->listLatestUpgrades($base,
                        $this->config->get('preferred_state', null, $channel), $installed,
                        $channel, $reg);
                } else {
                    $latest = $remote->call("package.listLatestReleases",
                        $this->config->get('preferred_state', null, $channel));
                    unset($remote);
                }
                PEAR::staticPopErrorHandling();
                if (PEAR::isError($latest)) {
                    $this->ui->outputData('Error getting channel info from ' . $channel .
                        ': ' . $latest->getMessage());
                    continue;
                }

                $latestReleases[$channel] = array_change_key_case($latest);
            }

            // check package for latest release
            if (isset($latestReleases[$channel][strtolower($name)])) {
                // if not set, up to date
                $inst_version = $reg->packageInfo($name, 'version', $channel);
                $channel_version = $latestReleases[$channel][strtolower($name)]['version'];
                if (version_compare($channel_version, $inst_version, "le")) {
                    // installed version is up-to-date
                    continue;
                }
                // maintain BC
                if ($command == 'upgrade-all') {
                    $this->ui->outputData(array('data' => 'Will upgrade ' .
                        $reg->parsedPackageNameToString($package)), $command);
                }
                $ret[] = $package;
            }
        }

        return $ret;
    }

}
?>
 

Редакция 69	Редакция 87
1	<?php	1	<?php
2	/**	2	/**
3	* PEAR_Command_Install (install, upgrade, upgrade-all, uninstall, bundle, run-scripts commands)	3	* PEAR_Command_Install (install, upgrade, upgrade-all, uninstall, bundle, run-scripts commands)
4	*	4	*
5	* PHP versions 4 and 5	5	* PHP versions 4 and 5
6	*	6	*
7	* LICENSE: This source file is subject to version 3.0 of the PHP license	7	* LICENSE: This source file is subject to version 3.0 of the PHP license
8	* that is available through the world-wide-web at the following URI:	8	* that is available through the world-wide-web at the following URI:
9	* http://www.php.net/license/3_0.txt. If you did not receive a copy of	9	* http://www.php.net/license/3_0.txt. If you did not receive a copy of
10	* the PHP License and are unable to obtain it through the web, please	10	* the PHP License and are unable to obtain it through the web, please
11	* send a note to license@php.net so we can mail you a copy immediately.	11	* send a note to license@php.net so we can mail you a copy immediately.
12	*	12	*
13	* @category pear	13	* @category pear
14	* @package PEAR	14	* @package PEAR
15	* @author Stig Bakken <ssb@php.net>	15	* @author Stig Bakken <ssb@php.net>
16	* @author Greg Beaver <cellog@php.net>	16	* @author Greg Beaver <cellog@php.net>
17	* @copyright 1997-2008 The PHP Group	17	* @copyright 1997-2008 The PHP Group
18	* @license http://www.php.net/license/3_0.txt PHP License 3.0	18	* @license http://www.php.net/license/3_0.txt PHP License 3.0
19	* @version CVS: $Id: Install.php,v 1.141 2008/05/13 18:32:29 cellog Exp $	19	* @version CVS: $Id: Install.php,v 1.141 2008/05/13 18:32:29 cellog Exp $
20	* @link http://pear.php.net/package/PEAR	20	* @link http://pear.php.net/package/PEAR
21	* @since File available since Release 0.1	21	* @since File available since Release 0.1
22	*/	22	*/
23		23
24	/**	24	/**
25	* base class	25	* base class
26	*/	26	*/
27	require_once 'PEAR/Command/Common.php';	27	require_once 'PEAR/Command/Common.php';
28		28
29	/**	29	/**
30	* PEAR commands for installation or deinstallation/upgrading of	30	* PEAR commands for installation or deinstallation/upgrading of
31	* packages.	31	* packages.
32	*	32	*
33	* @category pear	33	* @category pear
34	* @package PEAR	34	* @package PEAR
35	* @author Stig Bakken <ssb@php.net>	35	* @author Stig Bakken <ssb@php.net>
36	* @author Greg Beaver <cellog@php.net>	36	* @author Greg Beaver <cellog@php.net>
37	* @copyright 1997-2008 The PHP Group	37	* @copyright 1997-2008 The PHP Group
38	* @license http://www.php.net/license/3_0.txt PHP License 3.0	38	* @license http://www.php.net/license/3_0.txt PHP License 3.0
39	* @version Release: 1.7.2	39	* @version Release: 1.7.2
40	* @link http://pear.php.net/package/PEAR	40	* @link http://pear.php.net/package/PEAR
41	* @since Class available since Release 0.1	41	* @since Class available since Release 0.1
42	*/	42	*/
43	class PEAR_Command_Install extends PEAR_Command_Common	43	class PEAR_Command_Install extends PEAR_Command_Common
44	{	44	{
45	// {{{ properties	45	// {{{ properties
46		46
47	var $commands = array(	47	var $commands = array(
48	'install' => array(	48	'install' => array(
49	'summary' => 'Install Package',	49	'summary' => 'Install Package',
50	'function' => 'doInstall',	50	'function' => 'doInstall',
51	'shortcut' => 'i',	51	'shortcut' => 'i',
52	'options' => array(	52	'options' => array(
53	'force' => array(	53	'force' => array(
54	'shortopt' => 'f',	54	'shortopt' => 'f',
55	'doc' => 'will overwrite newer installed packages',	55	'doc' => 'will overwrite newer installed packages',
56	),	56	),
57	'loose' => array(	57	'loose' => array(
58	'shortopt' => 'l',	58	'shortopt' => 'l',
59	'doc' => 'do not check for recommended dependency version',	59	'doc' => 'do not check for recommended dependency version',
60	),	60	),
61	'nodeps' => array(	61	'nodeps' => array(
62	'shortopt' => 'n',	62	'shortopt' => 'n',
63	'doc' => 'ignore dependencies, install anyway',	63	'doc' => 'ignore dependencies, install anyway',
64	),	64	),
65	'register-only' => array(	65	'register-only' => array(
66	'shortopt' => 'r',	66	'shortopt' => 'r',
67	'doc' => 'do not install files, only register the package as installed',	67	'doc' => 'do not install files, only register the package as installed',
68	),	68	),
69	'soft' => array(	69	'soft' => array(
70	'shortopt' => 's',	70	'shortopt' => 's',
71	'doc' => 'soft install, fail silently, or upgrade if already installed',	71	'doc' => 'soft install, fail silently, or upgrade if already installed',
72	),	72	),
73	'nobuild' => array(	73	'nobuild' => array(
74	'shortopt' => 'B',	74	'shortopt' => 'B',
75	'doc' => 'don\'t build C extensions',	75	'doc' => 'don\'t build C extensions',
76	),	76	),
77	'nocompress' => array(	77	'nocompress' => array(
78	'shortopt' => 'Z',	78	'shortopt' => 'Z',
79	'doc' => 'request uncompressed files when downloading',	79	'doc' => 'request uncompressed files when downloading',
80	),	80	),
81	'installroot' => array(	81	'installroot' => array(
82	'shortopt' => 'R',	82	'shortopt' => 'R',
83	'arg' => 'DIR',	83	'arg' => 'DIR',
84	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',	84	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
85	),	85	),
86	'packagingroot' => array(	86	'packagingroot' => array(
87	'shortopt' => 'P',	87	'shortopt' => 'P',
88	'arg' => 'DIR',	88	'arg' => 'DIR',
89	'doc' => 'root directory used when packaging files, like RPM packaging',	89	'doc' => 'root directory used when packaging files, like RPM packaging',
90	),	90	),
91	'ignore-errors' => array(	91	'ignore-errors' => array(
92	'doc' => 'force install even if there were errors',	92	'doc' => 'force install even if there were errors',
93	),	93	),
94	'alldeps' => array(	94	'alldeps' => array(
95	'shortopt' => 'a',	95	'shortopt' => 'a',
96	'doc' => 'install all required and optional dependencies',	96	'doc' => 'install all required and optional dependencies',
97	),	97	),
98	'onlyreqdeps' => array(	98	'onlyreqdeps' => array(
99	'shortopt' => 'o',	99	'shortopt' => 'o',
100	'doc' => 'install all required dependencies',	100	'doc' => 'install all required dependencies',
101	),	101	),
102	'offline' => array(	102	'offline' => array(
103	'shortopt' => 'O',	103	'shortopt' => 'O',
104	'doc' => 'do not attempt to download any urls or contact channels',	104	'doc' => 'do not attempt to download any urls or contact channels',
105	),	105	),
106	'pretend' => array(	106	'pretend' => array(
107	'shortopt' => 'p',	107	'shortopt' => 'p',
108	'doc' => 'Only list the packages that would be downloaded',	108	'doc' => 'Only list the packages that would be downloaded',
109	),	109	),
110	),	110	),
111	'doc' => '[channel/]<package> ...	111	'doc' => '[channel/]<package> ...
112	Installs one or more PEAR packages. You can specify a package to	112	Installs one or more PEAR packages. You can specify a package to
113	install in four ways:	113	install in four ways:
114		114
115	"Package-1.0.tgz" : installs from a local file	115	"Package-1.0.tgz" : installs from a local file
116		116
117	"http://example.com/Package-1.0.tgz" : installs from	117	"http://example.com/Package-1.0.tgz" : installs from
118	anywhere on the net.	118	anywhere on the net.
119		119
120	"package.xml" : installs the package described in	120	"package.xml" : installs the package described in
121	package.xml. Useful for testing, or for wrapping a PEAR package in	121	package.xml. Useful for testing, or for wrapping a PEAR package in
122	another package manager such as RPM.	122	another package manager such as RPM.
123		123
124	"Package[-version/state][.tar]" : queries your default channel\'s server	124	"Package[-version/state][.tar]" : queries your default channel\'s server
125	({config master_server}) and downloads the newest package with	125	({config master_server}) and downloads the newest package with
126	the preferred quality/state ({config preferred_state}).	126	the preferred quality/state ({config preferred_state}).
127		127
128	To retrieve Package version 1.1, use "Package-1.1," to retrieve	128	To retrieve Package version 1.1, use "Package-1.1," to retrieve
129	Package state beta, use "Package-beta." To retrieve an uncompressed	129	Package state beta, use "Package-beta." To retrieve an uncompressed
130	file, append .tar (make sure there is no file by the same name first)	130	file, append .tar (make sure there is no file by the same name first)
131		131
132	To download a package from another channel, prefix with the channel name like	132	To download a package from another channel, prefix with the channel name like
133	"channel/Package"	133	"channel/Package"
134		134
135	More than one package may be specified at once. It is ok to mix these	135	More than one package may be specified at once. It is ok to mix these
136	four ways of specifying packages.	136	four ways of specifying packages.
137	'),	137	'),
138	'upgrade' => array(	138	'upgrade' => array(
139	'summary' => 'Upgrade Package',	139	'summary' => 'Upgrade Package',
140	'function' => 'doInstall',	140	'function' => 'doInstall',
141	'shortcut' => 'up',	141	'shortcut' => 'up',
142	'options' => array(	142	'options' => array(
143	'force' => array(	143	'force' => array(
144	'shortopt' => 'f',	144	'shortopt' => 'f',
145	'doc' => 'overwrite newer installed packages',	145	'doc' => 'overwrite newer installed packages',
146	),	146	),
147	'loose' => array(	147	'loose' => array(
148	'shortopt' => 'l',	148	'shortopt' => 'l',
149	'doc' => 'do not check for recommended dependency version',	149	'doc' => 'do not check for recommended dependency version',
150	),	150	),
151	'nodeps' => array(	151	'nodeps' => array(
152	'shortopt' => 'n',	152	'shortopt' => 'n',
153	'doc' => 'ignore dependencies, upgrade anyway',	153	'doc' => 'ignore dependencies, upgrade anyway',
154	),	154	),
155	'register-only' => array(	155	'register-only' => array(
156	'shortopt' => 'r',	156	'shortopt' => 'r',
157	'doc' => 'do not install files, only register the package as upgraded',	157	'doc' => 'do not install files, only register the package as upgraded',
158	),	158	),
159	'nobuild' => array(	159	'nobuild' => array(
160	'shortopt' => 'B',	160	'shortopt' => 'B',
161	'doc' => 'don\'t build C extensions',	161	'doc' => 'don\'t build C extensions',
162	),	162	),
163	'nocompress' => array(	163	'nocompress' => array(
164	'shortopt' => 'Z',	164	'shortopt' => 'Z',
165	'doc' => 'request uncompressed files when downloading',	165	'doc' => 'request uncompressed files when downloading',
166	),	166	),
167	'installroot' => array(	167	'installroot' => array(
168	'shortopt' => 'R',	168	'shortopt' => 'R',
169	'arg' => 'DIR',	169	'arg' => 'DIR',
170	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',	170	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
171	),	171	),
172	'ignore-errors' => array(	172	'ignore-errors' => array(
173	'doc' => 'force install even if there were errors',	173	'doc' => 'force install even if there were errors',
174	),	174	),
175	'alldeps' => array(	175	'alldeps' => array(
176	'shortopt' => 'a',	176	'shortopt' => 'a',
177	'doc' => 'install all required and optional dependencies',	177	'doc' => 'install all required and optional dependencies',
178	),	178	),
179	'onlyreqdeps' => array(	179	'onlyreqdeps' => array(
180	'shortopt' => 'o',	180	'shortopt' => 'o',
181	'doc' => 'install all required dependencies',	181	'doc' => 'install all required dependencies',
182	),	182	),
183	'offline' => array(	183	'offline' => array(
184	'shortopt' => 'O',	184	'shortopt' => 'O',
185	'doc' => 'do not attempt to download any urls or contact channels',	185	'doc' => 'do not attempt to download any urls or contact channels',
186	),	186	),
187	'pretend' => array(	187	'pretend' => array(
188	'shortopt' => 'p',	188	'shortopt' => 'p',
189	'doc' => 'Only list the packages that would be downloaded',	189	'doc' => 'Only list the packages that would be downloaded',
190	),	190	),
191	),	191	),
192	'doc' => '<package> ...	192	'doc' => '<package> ...
193	Upgrades one or more PEAR packages. See documentation for the	193	Upgrades one or more PEAR packages. See documentation for the
194	"install" command for ways to specify a package.	194	"install" command for ways to specify a package.
195		195
196	When upgrading, your package will be updated if the provided new	196	When upgrading, your package will be updated if the provided new
197	package has a higher version number (use the -f option if you need to	197	package has a higher version number (use the -f option if you need to
198	upgrade anyway).	198	upgrade anyway).
199		199
200	More than one package may be specified at once.	200	More than one package may be specified at once.
201	'),	201	'),
202	'upgrade-all' => array(	202	'upgrade-all' => array(
203	'summary' => 'Upgrade All Packages',	203	'summary' => 'Upgrade All Packages',
204	'function' => 'doUpgradeAll',	204	'function' => 'doUpgradeAll',
205	'shortcut' => 'ua',	205	'shortcut' => 'ua',
206	'options' => array(	206	'options' => array(
207	'nodeps' => array(	207	'nodeps' => array(
208	'shortopt' => 'n',	208	'shortopt' => 'n',
209	'doc' => 'ignore dependencies, upgrade anyway',	209	'doc' => 'ignore dependencies, upgrade anyway',
210	),	210	),
211	'register-only' => array(	211	'register-only' => array(
212	'shortopt' => 'r',	212	'shortopt' => 'r',
213	'doc' => 'do not install files, only register the package as upgraded',	213	'doc' => 'do not install files, only register the package as upgraded',
214	),	214	),
215	'nobuild' => array(	215	'nobuild' => array(
216	'shortopt' => 'B',	216	'shortopt' => 'B',
217	'doc' => 'don\'t build C extensions',	217	'doc' => 'don\'t build C extensions',
218	),	218	),
219	'nocompress' => array(	219	'nocompress' => array(
220	'shortopt' => 'Z',	220	'shortopt' => 'Z',
221	'doc' => 'request uncompressed files when downloading',	221	'doc' => 'request uncompressed files when downloading',
222	),	222	),
223	'installroot' => array(	223	'installroot' => array(
224	'shortopt' => 'R',	224	'shortopt' => 'R',
225	'arg' => 'DIR',	225	'arg' => 'DIR',
226	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',	226	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT), use packagingroot for RPM',
227	),	227	),
228	'ignore-errors' => array(	228	'ignore-errors' => array(
229	'doc' => 'force install even if there were errors',	229	'doc' => 'force install even if there were errors',
230	),	230	),
231	'loose' => array(	231	'loose' => array(
232	'doc' => 'do not check for recommended dependency version',	232	'doc' => 'do not check for recommended dependency version',
233	),	233	),
234	),	234	),
235	'doc' => '	235	'doc' => '
236	Upgrades all packages that have a newer release available. Upgrades are	236	Upgrades all packages that have a newer release available. Upgrades are
237	done only if there is a release available of the state specified in	237	done only if there is a release available of the state specified in
238	"preferred_state" (currently {config preferred_state}), or a state considered	238	"preferred_state" (currently {config preferred_state}), or a state considered
239	more stable.	239	more stable.
240	'),	240	'),
241	'uninstall' => array(	241	'uninstall' => array(
242	'summary' => 'Un-install Package',	242	'summary' => 'Un-install Package',
243	'function' => 'doUninstall',	243	'function' => 'doUninstall',
244	'shortcut' => 'un',	244	'shortcut' => 'un',
245	'options' => array(	245	'options' => array(
246	'nodeps' => array(	246	'nodeps' => array(
247	'shortopt' => 'n',	247	'shortopt' => 'n',
248	'doc' => 'ignore dependencies, uninstall anyway',	248	'doc' => 'ignore dependencies, uninstall anyway',
249	),	249	),
250	'register-only' => array(	250	'register-only' => array(
251	'shortopt' => 'r',	251	'shortopt' => 'r',
252	'doc' => 'do not remove files, only register the packages as not installed',	252	'doc' => 'do not remove files, only register the packages as not installed',
253	),	253	),
254	'installroot' => array(	254	'installroot' => array(
255	'shortopt' => 'R',	255	'shortopt' => 'R',
256	'arg' => 'DIR',	256	'arg' => 'DIR',
257	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',	257	'doc' => 'root directory used when installing files (ala PHP\'s INSTALL_ROOT)',
258	),	258	),
259	'ignore-errors' => array(	259	'ignore-errors' => array(
260	'doc' => 'force install even if there were errors',	260	'doc' => 'force install even if there were errors',
261	),	261	),
262	'offline' => array(	262	'offline' => array(
263	'shortopt' => 'O',	263	'shortopt' => 'O',
264	'doc' => 'do not attempt to uninstall remotely',	264	'doc' => 'do not attempt to uninstall remotely',
265	),	265	),
266	),	266	),
267	'doc' => '[channel/]<package> ...	267	'doc' => '[channel/]<package> ...
268	Uninstalls one or more PEAR packages. More than one package may be	268	Uninstalls one or more PEAR packages. More than one package may be
269	specified at once. Prefix with channel name to uninstall from a	269	specified at once. Prefix with channel name to uninstall from a
270	channel not in your default channel ({config default_channel})	270	channel not in your default channel ({config default_channel})
271	'),	271	'),
272	'bundle' => array(	272	'bundle' => array(
273	'summary' => 'Unpacks a Pecl Package',	273	'summary' => 'Unpacks a Pecl Package',
274	'function' => 'doBundle',	274	'function' => 'doBundle',
275	'shortcut' => 'bun',	275	'shortcut' => 'bun',
276	'options' => array(	276	'options' => array(
277	'destination' => array(	277	'destination' => array(
278	'shortopt' => 'd',	278	'shortopt' => 'd',
279	'arg' => 'DIR',	279	'arg' => 'DIR',
280	'doc' => 'Optional destination directory for unpacking (defaults to current path or "ext" if exists)',	280	'doc' => 'Optional destination directory for unpacking (defaults to current path or "ext" if exists)',
281	),	281	),
282	'force' => array(	282	'force' => array(
283	'shortopt' => 'f',	283	'shortopt' => 'f',
284	'doc' => 'Force the unpacking even if there were errors in the package',	284	'doc' => 'Force the unpacking even if there were errors in the package',
285	),	285	),
286	),	286	),
287	'doc' => '<package>	287	'doc' => '<package>
288	Unpacks a Pecl Package into the selected location. It will download the	288	Unpacks a Pecl Package into the selected location. It will download the
289	package if needed.	289	package if needed.
290	'),	290	'),
291	'run-scripts' => array(	291	'run-scripts' => array(
292	'summary' => 'Run Post-Install Scripts bundled with a package',	292	'summary' => 'Run Post-Install Scripts bundled with a package',
293	'function' => 'doRunScripts',	293	'function' => 'doRunScripts',
294	'shortcut' => 'rs',	294	'shortcut' => 'rs',
295	'options' => array(	295	'options' => array(
296	),	296	),
297	'doc' => '<package>	297	'doc' => '<package>
298	Run post-installation scripts in package <package>, if any exist.	298	Run post-installation scripts in package <package>, if any exist.
299	'),	299	'),
300	);	300	);
301		301
302	// }}}	302	// }}}
303	// {{{ constructor	303	// {{{ constructor
304		304
305	/**	305	/**
306	* PEAR_Command_Install constructor.	306	* PEAR_Command_Install constructor.
307	*	307	*
308	* @access public	308	* @access public
309	*/	309	*/
310	function PEAR_Command_Install(&$ui, &$config)	310	function PEAR_Command_Install(&$ui, &$config)
311	{	311	{
312	parent::PEAR_Command_Common($ui, $config);	312	parent::PEAR_Command_Common($ui, $config);
313	}	313	}
314		314
315	// }}}	315	// }}}
316		316
317	/**	317	/**
318	* For unit testing purposes	318	* For unit testing purposes
319	*/	319	*/
320	function &getDownloader(&$ui, $options, &$config)	320	function &getDownloader(&$ui, $options, &$config)
321	{	321	{
322	if (!class_exists('PEAR_Downloader')) {	322	if (!class_exists('PEAR_Downloader')) {
323	require_once 'PEAR/Downloader.php';	323	require_once 'PEAR/Downloader.php';
324	}	324	}
325	$a = &new PEAR_Downloader($ui, $options, $config);	325	$a = &new PEAR_Downloader($ui, $options, $config);
326	return $a;	326	return $a;
327	}	327	}
328		328
329	/**	329	/**
330	* For unit testing purposes	330	* For unit testing purposes
331	*/	331	*/
332	function &getInstaller(&$ui)	332	function &getInstaller(&$ui)
333	{	333	{
334	if (!class_exists('PEAR_Installer')) {	334	if (!class_exists('PEAR_Installer')) {
335	require_once 'PEAR/Installer.php';	335	require_once 'PEAR/Installer.php';
336	}	336	}
337	$a = &new PEAR_Installer($ui);	337	$a = &new PEAR_Installer($ui);
338	return $a;	338	return $a;
339	}	339	}
340		340
341	function enableExtension($binaries, $type)	341	function enableExtension($binaries, $type)
342	{	342	{
343	if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {	343	if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
344	return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');	344	return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
345	}	345	}
346	$ini = $this->_parseIni($phpini);	346	$ini = $this->_parseIni($phpini);
347	if (PEAR::isError($ini)) {	347	if (PEAR::isError($ini)) {
348	return $ini;	348	return $ini;
349	}	349	}
350	$line = 0;	350	$line = 0;
351	if ($type == 'extsrc' \|\| $type == 'extbin') {	351	if ($type == 'extsrc' \|\| $type == 'extbin') {
352	$search = 'extensions';	352	$search = 'extensions';
353	$enable = 'extension';	353	$enable = 'extension';
354	} else {	354	} else {
355	$search = 'zend_extensions';	355	$search = 'zend_extensions';
356	ob_start();	356	ob_start();
357	phpinfo(INFO_GENERAL);	357	phpinfo(INFO_GENERAL);
358	$info = ob_get_contents();	358	$info = ob_get_contents();
359	ob_end_clean();	359	ob_end_clean();
360	$debug = function_exists('leak') ? '_debug' : '';	360	$debug = function_exists('leak') ? '_debug' : '';
361	$ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';	361	$ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
362	$enable = 'zend_extension' . $debug . $ts;	362	$enable = 'zend_extension' . $debug . $ts;
363	}	363	}
364	foreach ($ini[$search] as $line => $extension) {	364	foreach ($ini[$search] as $line => $extension) {
365	if (in_array($extension, $binaries, true) \|\| in_array(	365	if (in_array($extension, $binaries, true) \|\| in_array(
366	$ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {	366	$ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
367	// already enabled - assume if one is, all are	367	// already enabled - assume if one is, all are
368	return true;	368	return true;
369	}	369	}
370	}	370	}
371	if ($line) {	371	if ($line) {
372	$newini = array_slice($ini['all'], 0, $line);	372	$newini = array_slice($ini['all'], 0, $line);
373	} else {	373	} else {
374	$newini = array();	374	$newini = array();
375	}	375	}
376	foreach ($binaries as $binary) {	376	foreach ($binaries as $binary) {
377	if ($ini['extension_dir']) {	377	if ($ini['extension_dir']) {
378	$binary = basename($binary);	378	$binary = basename($binary);
379	}	379	}
380	$newini[] = $enable . '="' . $binary . '"' . (OS_UNIX ? "\n" : "\r\n");	380	$newini[] = $enable . '="' . $binary . '"' . (OS_UNIX ? "\n" : "\r\n");
381	}	381	}
382	$newini = array_merge($newini, array_slice($ini['all'], $line));	382	$newini = array_merge($newini, array_slice($ini['all'], $line));
383	$fp = @fopen($phpini, 'wb');	383	$fp = @fopen($phpini, 'wb');
384	if (!$fp) {	384	if (!$fp) {
385	return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');	385	return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
386	}	386	}
387	foreach ($newini as $line) {	387	foreach ($newini as $line) {
388	fwrite($fp, $line);	388	fwrite($fp, $line);
389	}	389	}
390	fclose($fp);	390	fclose($fp);
391	return true;	391	return true;
392	}	392	}
393		393
394	function disableExtension($binaries, $type)	394	function disableExtension($binaries, $type)
395	{	395	{
396	if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {	396	if (!($phpini = $this->config->get('php_ini', null, 'pear.php.net'))) {
397	return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');	397	return PEAR::raiseError('configuration option "php_ini" is not set to php.ini location');
398	}	398	}
399	$ini = $this->_parseIni($phpini);	399	$ini = $this->_parseIni($phpini);
400	if (PEAR::isError($ini)) {	400	if (PEAR::isError($ini)) {
401	return $ini;	401	return $ini;
402	}	402	}
403	$line = 0;	403	$line = 0;
404	if ($type == 'extsrc' \|\| $type == 'extbin') {	404	if ($type == 'extsrc' \|\| $type == 'extbin') {
405	$search = 'extensions';	405	$search = 'extensions';
406	$enable = 'extension';	406	$enable = 'extension';
407	} else {	407	} else {
408	$search = 'zend_extensions';	408	$search = 'zend_extensions';
409	ob_start();	409	ob_start();
410	phpinfo(INFO_GENERAL);	410	phpinfo(INFO_GENERAL);
411	$info = ob_get_contents();	411	$info = ob_get_contents();
412	ob_end_clean();	412	ob_end_clean();
413	$debug = function_exists('leak') ? '_debug' : '';	413	$debug = function_exists('leak') ? '_debug' : '';
414	$ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';	414	$ts = preg_match('Thread Safety.+enabled', $info) ? '_ts' : '';
415	$enable = 'zend_extension' . $debug . $ts;	415	$enable = 'zend_extension' . $debug . $ts;
416	}	416	}
417	$found = false;	417	$found = false;
418	foreach ($ini[$search] as $line => $extension) {	418	foreach ($ini[$search] as $line => $extension) {
419	if (in_array($extension, $binaries, true) \|\| in_array(	419	if (in_array($extension, $binaries, true) \|\| in_array(
420	$ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {	420	$ini['extension_dir'] . DIRECTORY_SEPARATOR . $extension, $binaries, true)) {
421	$found = true;	421	$found = true;
422	break;	422	break;
423	}	423	}
424	}	424	}
425	if (!$found) {	425	if (!$found) {
426	// not enabled	426	// not enabled
427	return true;	427	return true;
428	}	428	}
429	$fp = @fopen($phpini, 'wb');	429	$fp = @fopen($phpini, 'wb');
430	if (!$fp) {	430	if (!$fp) {
431	return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');	431	return PEAR::raiseError('cannot open php.ini "' . $phpini . '" for writing');
432	}	432	}
433	if ($line) {	433	if ($line) {
434	$newini = array_slice($ini['all'], 0, $line);	434	$newini = array_slice($ini['all'], 0, $line);
435	// delete the enable line	435	// delete the enable line
436	$newini = array_merge($newini, array_slice($ini['all'], $line + 1));	436	$newini = array_merge($newini, array_slice($ini['all'], $line + 1));
437	} else {	437	} else {
438	$newini = array_slice($ini['all'], 1);	438	$newini = array_slice($ini['all'], 1);
439	}	439	}
440	foreach ($newini as $line) {	440	foreach ($newini as $line) {
441	fwrite($fp, $line);	441	fwrite($fp, $line);
442	}	442	}
443	fclose($fp);	443	fclose($fp);
444	return true;	444	return true;
445	}	445	}
446		446
447	function _parseIni($filename)	447	function _parseIni($filename)
448	{	448	{
449	if (file_exists($filename)) {	449	if (file_exists($filename)) {
450	if (filesize($filename) > 300000) {	450	if (filesize($filename) > 300000) {
451	return PEAR::raiseError('php.ini "' . $filename . '" is too large, aborting');	451	return PEAR::raiseError('php.ini "' . $filename . '" is too large, aborting');
452	}	452	}
453	ob_start();	453	ob_start();
454	phpinfo(INFO_GENERAL);	454	phpinfo(INFO_GENERAL);
455	$info = ob_get_contents();	455	$info = ob_get_contents();
456	ob_end_clean();	456	ob_end_clean();
457	$debug = function_exists('leak') ? '_debug' : '';	457	$debug = function_exists('leak') ? '_debug' : '';
458	$ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';	458	$ts = preg_match('/Thread Safety.+enabled/', $info) ? '_ts' : '';
459	$zend_extension_line = 'zend_extension' . $debug . $ts;	459	$zend_extension_line = 'zend_extension' . $debug . $ts;
460	$all = @file($filename);	460	$all = @file($filename);
461	if (!$all) {	461	if (!$all) {
462	return PEAR::raiseError('php.ini "' . $filename .'" could not be read');	462	return PEAR::raiseError('php.ini "' . $filename .'" could not be read');
463	}	463	}
464	$zend_extensions = $extensions = array();	464	$zend_extensions = $extensions = array();
465	// assume this is right, but pull from the php.ini if it is found	465	// assume this is right, but pull from the php.ini if it is found
466	$extension_dir = ini_get('extension_dir');	466	$extension_dir = ini_get('extension_dir');
467	foreach ($all as $linenum => $line) {	467	foreach ($all as $linenum => $line) {
468	$line = trim($line);	468	$line = trim($line);
469	if (!$line) {	469	if (!$line) {
470	continue;	470	continue;
471	}	471	}
472	if ($line[0] == ';') {	472	if ($line[0] == ';') {
473	continue;	473	continue;
474	}	474	}
475	if (strtolower(substr($line, 0, 13)) == 'extension_dir') {	475	if (strtolower(substr($line, 0, 13)) == 'extension_dir') {
476	$line = trim(substr($line, 13));	476	$line = trim(substr($line, 13));
477	if ($line[0] == '=') {	477	if ($line[0] == '=') {
478	$x = trim(substr($line, 1));	478	$x = trim(substr($line, 1));
479	$x = explode(';', $x);	479	$x = explode(';', $x);
480	$extension_dir = str_replace('"', '', array_shift($x));	480	$extension_dir = str_replace('"', '', array_shift($x));
481	continue;	481	continue;
482	}	482	}
483	}	483	}
484	if (strtolower(substr($line, 0, 9)) == 'extension') {	484	if (strtolower(substr($line, 0, 9)) == 'extension') {
485	$line = trim(substr($line, 9));	485	$line = trim(substr($line, 9));
486	if ($line[0] == '=') {	486	if ($line[0] == '=') {
487	$x = trim(substr($line, 1));	487	$x = trim(substr($line, 1));
488	$x = explode(';', $x);	488	$x = explode(';', $x);
489	$extensions[$linenum] = str_replace('"', '', array_shift($x));	489	$extensions[$linenum] = str_replace('"', '', array_shift($x));
490	continue;	490	continue;
491	}	491	}
492	}	492	}
493	if (strtolower(substr($line, 0, strlen($zend_extension_line))) ==	493	if (strtolower(substr($line, 0, strlen($zend_extension_line))) ==
494	$zend_extension_line) {	494	$zend_extension_line) {
495	$line = trim(substr($line, strlen($zend_extension_line)));	495	$line = trim(substr($line, strlen($zend_extension_line)));
496	if ($line[0] == '=') {	496	if ($line[0] == '=') {
497	$x = trim(substr($line, 1));	497	$x = trim(substr($line, 1));
498	$x = explode(';', $x);	498	$x = explode(';', $x);
499	$zend_extensions[$linenum] = str_replace('"', '', array_shift($x));	499	$zend_extensions[$linenum] = str_replace('"', '', array_shift($x));
500	continue;	500	continue;

Хранилища Subversion ant

(root)/tags/0.2/lib/PEAR/Command/Install.php @ 444 - Редакция 69 → 87