1. sfPluginManager.class.php
  2. /**
 * sfPluginManager allows you to manage plugins installation and uninstallation.
 *
 * @package    symfony
 * @subpackage plugin
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfPluginManager.class.php 21908 2009-09-11 12:06:21Z fabien $
 */
  3. class sfPluginManager
  4. {
  5.   protected
  6.    $dispatcher  = null,
  7.    $environment = null,
  8.    $installing  = array();
  10.   /**
  11.    * Constructs a new sfPluginManager.
  12.    *
  13.    * @param sfEventDispatcher $dispatcher   An event dispatcher instance
  14.    * @param sfPearEnvironment $environment  A sfPearEnvironment instance
  15.    */
  16.   public function __construct(sfEventDispatcher $dispatcher, sfPearEnvironment $environment)
  17.   {
  18.     $this->initialize($dispatcher, $environment);
  19.   }
  21.   /**
  22.    * Initializes this sfPluginManager instance.
  23.    *
  24.    * see sfPearEnvironment for available options.
  25.    *
  26.    * @param sfEventDispatcher $dispatcher   An event dispatcher instance
  27.    * @param sfPearEnvironment $environment  A sfPearEnvironment instance
  28.    */
  29.   public function initialize(sfEventDispatcher $dispatcher, sfPearEnvironment $environment)
  30.   {
  31.     $this->dispatcher  = $dispatcher;
  32.     $this->environment = $environment;
  34.     // configure this plugin manager
  35.     $this->configure();
  36.   }
  38.   /**
  39.    * Configures this plugin manager.
  40.    */
  41.   public function configure()
  42.   {
  43.   }
  45.   /**
  46.    * Returns the sfPearEnvironment instance.
  47.    *
  48.    * @return sfPearEnvironment The sfPearEnvironment instance
  49.    */
  50.   public function getEnvironment()
  51.   {
  52.     return $this->environment;
  53.   }
  55.   /**
  56.    * Returns a list of installed plugin.
  57.    *
  58.    * @return array An array of installed plugins
  59.    */
  60.   public function getInstalledPlugins()
  61.   {
  62.     $installed = array();
  63.     foreach ($this->environment->getRegistry()->packageInfo(null, null, null) as $channel => $packages)
  64.     {
  65.       foreach ($packages as $package)
  66.       {
  67.         $installed[] = $this->environment->getRegistry()->getPackage(isset($package['package']) ? $package['package'] : $package['name'], $channel);
  68.       }
  69.     }
  71.     return $installed;
  72.   }
  74.   /**
  75.    * Installs a plugin.
  76.    *
  77.    * If you don't pass a version, it will install the latest version available
  78.    * for the current project symfony version.
  79.    *
  80.    * Available options:
  81.    *
  82.    *  * channel:      The plugin channel name
  83.    *  * version:      The version to install
  84.    *  * stability:    The stability preference
  85.    *  * install_deps: Whether to automatically install dependencies (default to false)
  86.    *
  87.    * @param string $plugin  The plugin name
  88.    * @param array  $options An array of options
  89.    *
  90.    * @return Boolean|string true if the plugin is already installed, the name of the installed plugin otherwise
  91.    */
  92.   public function installPlugin($plugin, $options = array())
  93.   {
  94.     $this->installing = array();
  96.     return $this->doInstallPlugin($plugin, $options);
  97.   }
  99.   /**
  100.    * Installs a plugin
  101.    *
  102.    * @see installPlugin()
  103.    */
  104.   protected function doInstallPlugin($plugin, $options = array())
  105.   {
  106.     $channel   = isset($options['channel']) ? $options['channel'] : $this->environment->getConfig()->get('default_channel');
  107.     $stability = isset($options['stability']) ? $options['stability'] : $this->environment->getConfig()->get('preferred_state', null, $channel);
  108.     $version   = isset($options['version']) ? $options['version'] : null;
  110.     $isPackage = true;
  111.     if (0 === strpos($plugin, 'http://') || file_exists($plugin))
  112.     {
  113.       if (0 === strpos($plugin, 'http://plugins.symfony-project.'))
  114.       {
  115.         throw new sfPluginException("You try to install a symfony 1.0 plugin.\nPlease read the help message of this task to know how to install a plugin for the current version of symfony.");
  116.       }
  118.       $download  = $plugin;
  119.       $isPackage = false;
  120.     }
  121.     else if (false !== strpos($plugin, '/'))
  122.     {
  123.       list($channel, $plugin) = explode('/', $plugin);
  124.     }
  126.     $this->dispatcher->notify(new sfEvent($this, 'plugin.pre_install', array('channel' => $channel, 'plugin' => $plugin, 'is_package' => $isPackage)));
  128.     if ($isPackage)
  129.     {
  130.       $this->environment->getRest()->setChannel($channel);
  132.       if (!preg_match(PEAR_COMMON_PACKAGE_NAME_PREG, $plugin))
  133.       {
  134.         throw new sfPluginException(sprintf('Plugin name "%s" is not a valid package name', $plugin));
  135.       }
  137.       if (!$version)
  138.       {
  139.         $version = $this->getPluginVersion($plugin, $stability);
  140.       }
  141.       else
  142.       {
  143.         if (!$this->isPluginCompatible($plugin, $version))
  144.         {
  145.           throw new sfPluginDependencyException(sprintf('Plugin "%s" in version "%s" is not compatible with the current application', $plugin, $version));
  146.         }
  147.       }
  149.       if (!preg_match(PEAR_COMMON_PACKAGE_VERSION_PREG, $version))
  150.       {
  151.         throw new sfPluginException(sprintf('Plugin version "%s" is not a valid version', $version));
  152.       }
  154.       $existing = $this->environment->getRegistry()->packageInfo($plugin, 'version', $channel);
  155.       if (version_compare($existing, $version) === 0)
  156.       {
  157.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array('Plugin is already installed')));
  159.         return true;
  160.       }
  162.       // skip if the plugin is already installing and we are here through a dependency)
  163.       if (isset($this->installing[$channel.'/'.$plugin]))
  164.       {
  165.         return true;
  166.       }
  168.       // convert the plugin package into a discrete download URL
  169.       $download = $this->environment->getRest()->getPluginDownloadURL($plugin, $version, $stability);
  170.       if (PEAR::isError($download))
  171.       {
  172.         throw new sfPluginException(sprintf('Problem downloading the plugin "%s": %s', $plugin, $download->getMessage()));
  173.       }
  174.     }
  176.     // download the plugin and install
  177.     $class = $this->environment->getOption('downloader_base_class');
  178.     $downloader = new $class($this, array('upgrade' => true), $this->environment->getConfig());
  180.     $this->installing[$channel.'/'.$plugin] = true;
  182.     if ($isPackage)
  183.     {
  184.       $this->checkPluginDependencies($plugin, $version, array(
  185.         'install_deps' => isset($options['install_deps']) ? (bool) $options['install_deps'] : false,
  186.         'stability'    => $stability,
  187.       ));
  188.     }
  190.     // download the actual URL to the plugin
  191.     $downloaded = $downloader->download(array($download));
  192.     if (PEAR::isError($downloaded))
  193.     {
  194.       throw new sfPluginException(sprintf('Problem when downloading "%s": %s', $download, $downloaded->getMessage()));
  195.     }
  196.     $errors = $downloader->getErrorMsgs();
  197.     if (count($errors))
  198.     {
  199.       $err = array();
  200.       foreach ($errors as $error)
  201.       {
  202.         $err[] = $error;
  203.       }
  205.       if (!count($downloaded))
  206.       {
  207.         throw new sfPluginException(sprintf('Plugin "%s" installation failed: %s', $plugin, implode("\n", $err)));
  208.       }
  209.     }
  211.     $pluginPackage = $downloaded[0];
  213.     $installer = new PEAR_Installer($this);
  214.     $installer->setOptions(array('upgrade' => true));
  215.     $packages = array($pluginPackage);
  216.     $installer->sortPackagesForInstall($packages);
  217.     PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
  218.     $err = $installer->setDownloadedPackages($packages);
  219.     if (PEAR::isError($err))
  220.     {
  221.       PEAR::staticPopErrorHandling();
  222.       throw new sfPluginException($err->getMessage());
  223.     }
  225.     $info = $installer->install($pluginPackage, array('upgrade' => true));
  226.     PEAR::staticPopErrorHandling();
  227.     if (PEAR::isError($info))
  228.     {
  229.       throw new sfPluginException(sprintf('Installation of "%s" plugin failed: %s', $plugin, $info->getMessage()));
  230.     }
  232.     if (is_array($info))
  233.     {
  234.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Installation successful for plugin "%s"', $plugin))));
  236.       $this->dispatcher->notify(new sfEvent($this, 'plugin.post_install', array('channel' => $channel, 'plugin' => $pluginPackage->getPackage())));
  238.       unset($this->installing[$channel.'/'.$plugin]);
  240.       return $pluginPackage->getPackage();
  241.     }
  242.     else
  243.     {
  244.       throw new sfPluginException(sprintf('Installation of "%s" plugin failed', $plugin));
  245.     }
  246.   }
  248.   /**
  249.    * Uninstalls a plugin.
  250.    *
  251.    * @param string $plugin  The plugin name
  252.    * @param string $channel The channel name
  253.    */
  254.   public function uninstallPlugin($plugin, $channel = null)
  255.   {
  256.     if (false !== strpos($plugin, '/'))
  257.     {
  258.       list($channel, $plugin) = explode('/', $plugin);
  259.     }
  261.     $channel = null === $channel ? $this->environment->getConfig()->get('default_channel') : $channel;
  263.     $existing = $this->environment->getRegistry()->packageInfo($plugin, 'version', $channel);
  264.     if (null === $existing)
  265.     {
  266.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Plugin "%s" is not installed', $plugin))));
  268.       return false;
  269.     }
  271.     $this->dispatcher->notify(new sfEvent($this, 'plugin.pre_uninstall', array('channel' => $channel, 'plugin' => $plugin)));
  273.     $package = $this->environment->getRegistry()->parsePackageName($plugin, $channel);
  275.     $installer = new PEAR_Installer($this);
  276.     $packages = array($this->environment->getRegistry()->getPackage($plugin, $channel));
  277.     $installer->setUninstallPackages($packages);
  278.     $ret = $installer->uninstall($package);
  279.     if (PEAR::isError($ret))
  280.     {
  281.       throw new sfPluginException(sprintf('Problem uninstalling plugin "%s": %s', $plugin, $ret->getMessage()));
  282.     }
  284.     if ($ret)
  285.     {
  286.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Uninstallation successful for plugin "%s"', $plugin))));
  288.       $this->dispatcher->notify(new sfEvent($this, 'plugin.post_uninstall', array('channel' => $channel, 'plugin' => $plugin)));
  289.     }
  290.     else
  291.     {
  292.       throw new sfPluginException(sprintf('Uninstallation of "%s" plugin failed', $plugin));
  293.     }
  295.     return $ret;
  296.   }
  298.   /**
  299.    * Checks all plugin dependencies.
  300.    *
  301.    * Available options:
  302.    *
  303.    *  * stability:    The stability preference
  304.    *  * install_deps: Whether to automatically install dependencies (default to false)
  305.    *
  306.    * @param string $plugin  The plugin name
  307.    * @param string $version The plugin version
  308.    * @param array  $options An array of options
  309.    */
  310.   public function checkPluginDependencies($plugin, $version, $options = false)
  311.   {
  312.     $dependencies = $this->environment->getRest()->getPluginDependencies($plugin, $version);
  314.     if (!isset($dependencies['required']) || !isset($dependencies['required']['package']))
  315.     {
  316.       return;
  317.     }
  319.     $deps = $dependencies['required']['package'];
  320.     if (!isset($deps[0]))
  321.     {
  322.       $deps = array($deps);
  323.     }
  325.     foreach ($deps as $dependency)
  326.     {
  327.       if (!$this->checkDependency($dependency))
  328.       {
  329.         $version = (isset($dependency['min']) ? ' >= '.$dependency['min'] : '').(isset($dependency['max']) ? ' <= '.$dependency['max'] : '').(isset($dependency['exclude']) ? ' exclude '.$dependency['exclude'] : '');
  331.         if (isset($options['install_deps']) && $options['install_deps'])
  332.         {
  333.           try
  334.           {
  335.             $this->doInstallPlugin($dependency['name'], array_merge($options, array('channel' => $dependency['channel'])));
  336.           }
  337.           catch (sfException $e)
  338.           {
  339.             throw new sfPluginRecursiveDependencyException(sprintf('Unable to install plugin "%s" (version %s) because it depends on plugin "%s" which cannot be installed automatically: %s', $plugin, $version, $dependency['name'], $e->getMessage()));
  340.           }
  342.           continue;
  343.         }
  345.         throw new sfPluginDependencyException(sprintf('Unable to install plugin "%s" (version %s) because it depends on plugin "%s" which is not installed (install dependencies by hand or use the --install_deps option for automatic installation).', $plugin, $version, $dependency['name']));
  346.       }
  347.     }
  348.   }
  350.   /**
  351.    * Gets the "best" version available for a given plugin.
  352.    *
  353.    * @param  string $plugin     The plugin name
  354.    * @param  string $stability  The stability name
  355.    *
  356.    * @return string The version
  357.    */
  358.   public function getPluginVersion($plugin, $stability = null)
  359.   {
  360.     $versions = $this->environment->getRest()->getPluginVersions($plugin, $stability);
  361.     foreach ($versions as $version)
  362.     {
  363.       if (!$this->isPluginCompatible($plugin, $version))
  364.       {
  365.         continue;
  366.       }
  368.       return $version;
  369.     }
  371.     throw new sfPluginDependencyException(sprintf('No release available for plugin "%s" in state "%s" that satisfies the application requirements.', $plugin, $stability));
  372.   }
  374.   /**
  375.    * Returns true if the plugin is comptatible with your environment.
  376.    *
  377.    * @param  string $plugin   The plugin name
  378.    * @param  string $version  The plugin version
  379.    *
  380.    * @return Boolean true if the plugin is compatible, false otherwise
  381.    */
  382.   public function isPluginCompatible($plugin, $version)
  383.   {
  384.     $dependencies = $this->environment->getRest()->getPluginDependencies($plugin, $version);
  386.     if (!isset($dependencies['required']) || !isset($dependencies['required']['package']))
  387.     {
  388.       return true;
  389.     }
  391.     $deps = $dependencies['required']['package'];
  392.     if (!isset($deps[0]))
  393.     {
  394.       $deps = array($deps);
  395.     }
  397.     foreach ($deps as $dependency)
  398.     {
  399.       if (!$this->isPluginCompatibleWithDependency($dependency))
  400.       {
  401.         return false;
  402.       }
  403.     }
  405.     return true;
  406.   }
  408.   /**
  409.    * Returns the license for a given plugin.
  410.    *
  411.    * @param string $plugin    The plugin name
  412.    * @param array  $options   An array of options
  413.    *
  414.    * @return string The license
  415.    *
  416.    * @see installPlugin() for available options
  417.    */
  418.   public function getPluginLicense($plugin, $options = array())
  419.   {
  420.     $channel   = isset($options['channel']) ? $options['channel'] : $this->environment->getConfig()->get('default_channel');
  421.     $stability = isset($options['stability']) ? $options['stability'] : $this->environment->getConfig()->get('preferred_state', null, $channel);
  422.     $version   = isset($options['version']) ? $options['version'] : null;
  424.     $rest = $this->environment->getRest();
  425.     $rest->setChannel(null === $channel ? $this->environment->getConfig()->get('default_channel') : $channel);
  427.     if (null === $version)
  428.     {
  429.       try
  430.       {
  431.         $version = $this->getPluginVersion($plugin, $stability);
  432.       }
  433.       catch (Exception $e)
  434.       {
  435.         // no release available
  436.         return false;
  437.       }
  438.     }
  439.     else
  440.     {
  441.       if (!$this->isPluginCompatible($plugin, $version))
  442.       {
  443.         throw new sfPluginDependencyException(sprintf('Plugin "%s" in version "%s" is not compatible with the current application', $plugin, $version));
  444.       }
  445.     }
  447.     return $rest->getPluginLicense($plugin, $version);
  448.   }
  450.   /**
  451.    * Returns true if the plugin is comptatible with the dependency.
  452.    *
  453.    * @param  array   $dependency An dependency array
  454.    *
  455.    * @return Boolean true if the plugin is compatible, false otherwise
  456.    */
  457.   protected function isPluginCompatibleWithDependency($dependency)
  458.   {
  459.     return true;
  460.   }
  462.   /**
  463.    * Checks that the dependency is valid.
  464.    *
  465.    * @param  array   $dependency A dependency array
  466.    *
  467.    * @return Boolean true if the dependency is valid, false otherwise
  468.    */
  469.   protected function checkDependency($dependency)
  470.   {
  471.     $dependencyChecker = new PEAR_Dependency2($this->environment->getConfig(), array(), array('package' => '', 'channel' => ''));
  473.     PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
  474.     $e = $dependencyChecker->validatePackageDependency($dependency, true, array());
  475.     PEAR::staticPopErrorHandling();
  476.     if (PEAR::isError($e))
  477.     {
  478.       return false;
  479.     }
  481.     return true;
  482.   }
  483. }
Debug toolbar