Source for file PearWrapper.php

Documentation is available at PearWrapper.php

  1. <?php
  2. // vim: foldmethod=marker
  3. /**
  4.  *  PearWrapper.php
  5.  *
  6.  *  @author     ICHII Takashi <ichii386@schweetheart.jp>
  7.  *  @license    http://www.opensource.org/licenses/bsd-license.php The BSD License
  8.  *  @package    Ethna
  9.  *  @version    $Id: 0d5ac26a60682608f56c627841bb2f745d99a3c1 $
  10.  */
  11.  
  12. require_once 'PEAR.php';
  13. require_once 'PEAR/Config.php';
  14. require_once 'PEAR/Command.php';
  15. require_once 'PEAR/PackageFile.php';
  16.  
  17. // {{{ Ethna_PearWrapper
  18. /**
  19.  *  wrapper class for PEAR_Command
  20.  *  This class should be instantiated in ethna handler.
  21.  *
  22.  *  @author     ICHII Takashi <ichii386@schweetheart.jp>
  23.  *  @access     public
  24.  *  @package    Ethna
  25.  */
  26. class Ethna_PearWrapper
  27. {
  28.     // {{{ properties
  29.     /**#@+
  30.      *  @access     private
  31.      */
  32.  
  33.     /** @protected    string  channel url of ethna repositry */
  34.     protected $channel;
  35.  
  36.     /** @protected    string  target, 'master' or 'local' */
  37.     protected $target;
  38.  
  39.     /** @protected    object  controller object collesponding to the target */
  40.     protected $target_ctl;
  41.  
  42.     /** @protected    object  PEAR_Config     PEAR_Config object */
  43.     protected $config;
  44.  
  45.     /** @protected    object  PEAR_Registry   PEAR_Registry object */
  46.     protected $registry;
  47.  
  48.     /** @protected    object  PEAR_Frontend   PEAR_Frontend(_CLI) object */
  49.     protected $ui;
  50.  
  51.     /** @protected    array   options for pearcmd */
  52.     protected $_pearopt;
  53.  
  54.     /**#@-*/
  55.     // }}}
  56.  
  57.     // {{{ constructor, initializer
  58.     /**
  59.      *  Ethna_PearWrapper constructor
  60.      *
  61.      *  @access public
  62.      */
  63.     public function __construct()
  64.     {
  65.         $this->channel = null;
  66.         $this->config = null;
  67.         $this->registry = null;
  68.         $this->ui = null;
  69.         $this->target = null;
  70.         $this->target_ctl = null;
  71.     }
  72.  
  73.     /**
  74.      *  setup PEAR_Config and so on.
  75.      *
  76.      *  @param  string      $target     whether 'master' or 'local'
  77.      *  @param  string|null$app_dir    local application directory.
  78.      *  @param  string|null$channel    channel for the package repository.
  79.      *  @return true|Ethna_Error
  80.      */
  81.     public function init($target, $app_dir = null, $channel = null)
  82.     {
  83.         $true = true;
  84.         if ($target == 'master') {
  85.             $this->target = 'master';
  86.         } else {
  87.             // default target is 'local'.
  88.             $this->target = 'local';
  89.         }
  90.  
  91.         // setup PEAR_Frontend
  92.         PEAR_Command::setFrontendType('CLI');
  93.         $this->ui = PEAR_Command::getFrontendObject();
  94.  
  95.         // set PEAR's error handling
  96.         // TODO: if PEAR/Command/Install.php is newer than 1.117, displayError goes well.
  97.         PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, array($this->ui, 'displayFatalError'));
  98.  
  99.         // set channel
  100.         $master_setting = Ethna_Handle::getMasterSetting('repositry');
  101.         if ($channel !== null) {
  102.             $this->channel = $channel;
  103.         } else if (isset($master_setting["channel_{$target}"])) {
  104.             $this->channel = $master_setting["channel_{$target}"];
  105.         } else {
  106.             $this->channel = 'pear.ethna.jp';
  107.         }
  108.  
  109.         // set target controller
  110.         if ($target == 'master') {
  111.             $this->target_ctl = Ethna_Handle::getEthnaController();
  112.         } else {
  113.             $this->target_ctl = Ethna_Handle::getAppController($app_dir);
  114.         }
  115.         if (Ethna::isError($this->target_ctl)) {
  116.             return $this->target_ctl;
  117.         }
  118.  
  119.         // setup PEAR_Config
  120.         if ($target == 'master') {
  121.             $ret = $this->_setMasterConfig();
  122.         } else {
  123.             $ret = $this->_setLocalConfig();
  124.         }
  125.         if (Ethna::isError($ret)) {
  126.             return $ret;
  127.         }
  128.         $this->ui->setConfig($this->config);
  129.  
  130.         // setup PEAR_Registry
  131.         $this->registry = $this->config->getRegistry();
  132.  
  133.         return $true;
  134.     }
  135.  
  136.     /**
  137.      *  config for master.
  138.      *
  139.      *  @return true|Ethna_Error
  140.      *  @access private
  141.      */
  142.     private function _setMasterConfig()
  143.     {
  144.         $true = true;
  145.  
  146.         // setup config
  147.         $this->config = PEAR_Config::singleton();
  148.  
  149.         // setup channel
  150.         $reg = $this->config->getRegistry();
  151.         if ($reg->channelExists($this->channel) == false) {
  152.             $ret = $this->doChannelDiscover();
  153.             if (Ethna::isError($ret)) {
  154.                 return $ret;
  155.             }
  156.         }
  157.  
  158.         return $true;
  159.     }
  160.  
  161.     /**
  162.      *  config for local.
  163.      *
  164.      *  @return true|Ethna_Error
  165.      *  @access protected
  166.      */
  167.     protected function _setLocalConfig()
  168.     {
  169.         $true = true;
  170.  
  171.         // determine dirs
  172.         $base = $this->target_ctl->getBaseDir();
  173.         $bin  = $this->target_ctl->getDirectory('bin');
  174.         $tmp  = $this->target_ctl->getDirectory('tmp');
  175.         $dirs = array(
  176.                 'php_dir'       => "{$base}/skel",
  177.                 'bin_dir'       => "{$bin}",
  178.                 'cache_dir'     => "{$tmp}/.pear/cache",
  179.                 'download_dir'  => "{$tmp}/.pear/download",
  180.                 'temp_dir'      => "{$tmp}/.pear/temp",
  181.                 'doc_dir'       => "{$tmp}/.pear/doc",
  182.                 'ext_dir'       => "{$tmp}/.pear/ext",
  183.                 'data_dir'      => "{$tmp}/.pear/data",
  184.                 'test_dir'      => "{$tmp}/.pear/test",
  185.                 );
  186.  
  187.         // mkdir
  188.         foreach ($dirs as $key => $dir) {
  189.             if (is_dir($dir) == false) {
  190.                 Ethna_Util::mkdir($dir, 0755);
  191.             }
  192.         }
  193.  
  194.         $pearrc = "{$base}/skel/.pearrc";
  195.         $this->config = PEAR_Config::singleton($pearrc);
  196.  
  197.         // read local .pearrc if exists.
  198.         if (is_file($pearrc) && is_readable($pearrc)) {
  199.             $this->config->readConfigFile($pearrc);
  200.         }
  201.  
  202.         // set dirs to config
  203.         foreach ($dirs as $key => $dir) {
  204.             $this->config->set($key, $dir);
  205.         }
  206.  
  207.         // setup channel
  208.         $reg = $this->config->getRegistry();
  209.         if ($reg->channelExists($this->channel) == false) {
  210.             $ret = $this->doChannelDiscover();
  211.             if (Ethna::isError($ret)) {
  212.                 return $ret;
  213.             }
  214.         }
  215.         $this->config->set('default_channel', $this->channel);
  216.  
  217.         // write local .pearrc
  218.         $this->config->writeConfigFile();
  219.  
  220.         return $true;
  221.     }
  222.     // }}}
  223.  
  224.     // {{{ doClearCache
  225.     /**
  226.      *  do clear-cache
  227.      *
  228.      *  @return true|Ethna_Error
  229.      */
  230.     public function doClearCache()
  231.     {
  232.         $true = true;
  233.         $r = $this->_run('clear-cache', array(), array());
  234.         if (PEAR::isError($r)) {
  235.             return $r;
  236.         }
  237.         return $true;
  238.     }
  239.     // }}}
  240.  
  241.     // {{{ doChannelDiscover
  242.     /**
  243.      *  do channel-discover
  244.      *
  245.      *  @return true|Ethna_Error
  246.      */
  247.     public function doChannelDiscover()
  248.     {
  249.         $true = true;
  250.         $r = $this->_run('channel-discover', array(), array($this->channel));
  251.         if (PEAR::isError($r)) {
  252.             return $r;
  253.         }
  254.         return $true;
  255.     }
  256.     // }}}
  257.  
  258.     // {{{ isChannelExists
  259.     /**
  260.      *  whether channel discovered or not
  261.      *
  262.      *  @return bool 
  263.      */
  264.     public function isChannelExists()
  265.     {
  266.         return $this->registry->channelExists($this->channel);
  267.     }
  268.     // }}}
  269.  
  270.     // {{{ doChannelUpdate
  271.     /**
  272.      *  do channel-update
  273.      *
  274.      *  @return true|Ethna_Error
  275.      */
  276.     public function doChannelUpdate()
  277.     {
  278.         $true = true;
  279.         if ($this->isChannelExists() == false) {
  280.             $r = $this->doChannelDiscover();
  281.             if (PEAR::isError($r)) {
  282.                 return $r;
  283.             }
  284.         }
  285.         $r = $this->_run('channel-update', array(), array($this->channel));
  286.         if (PEAR::isError($r)) {
  287.             return $r;
  288.         }
  289.         return $true;
  290.     }
  291.     // }}}
  292.  
  293.     // {{{ _doInstallOrUpgrade
  294.     /**
  295.      *  do install
  296.      *
  297.      *  @param  string  $command    'install' or 'upgrade'
  298.      *  @param  string  $package    package string
  299.      *  @return true|Ethna_Error
  300.      *  @access private
  301.      */
  302.     private function _doInstallOrUpgrade($command, $package)
  303.     {
  304.         $true = true;
  305.         $r = $this->_run($command, array(), array($package));
  306.         if (PEAR::isError($r)) {
  307.             return $r;
  308.         }
  309.         return $true;
  310.     }
  311.     // }}}
  312.         
  313.     // {{{ doInstall
  314.     /**
  315.      *  do install
  316.      *
  317.      *  @param  string  $pkg_name   package name.
  318.      *  @param  string  $state      package state.
  319.      *  @return true|Ethna_Error
  320.      */
  321.     public function doInstall($pkg_name, $state = null)
  322.     {
  323.         $pkg = "{$this->channel}/{$pkg_name}";
  324.         if ($state !== null) {
  325.             $pkg = "{$pkg}-{$state}";
  326.         }
  327.         $r = $this->_doInstallOrUpgrade('install', $pkg); 
  328.         return $r;
  329.     }
  330.     // }}}
  332.     // {{{ doInstallFromTgz
  333.     /**
  334.      *  do install from local tgz file
  335.      *
  336.      *  @param  string  $pkg_file   package filename
  337.      *  @return true|Ethna_Error
  338.      */
  339.     public function doInstallFromTgz($pkg_file)
  340.     {
  341.         $r = $this->_doInstallOrUpgrade('install', $pkg_file); 
  342.         return $r;
  343.     }
  344.     // }}}
  346.     // {{{ doUpgrade
  347.     /**
  348.      *  do upgrade
  349.      *
  350.      *  @param  string  $pkg_name   package name.
  351.      *  @param  string  $state      package state.
  352.      *  @return true|Ethna_Error
  353.      */
  354.     public function doUpgrade($pkg_name, $state = null)
  355.     {
  356.         $pkg = "{$this->channel}/{$pkg_name}";
  357.         if ($state !== null) {
  358.             $pkg = "{$pkg}-{$state}";
  359.         }
  360.         $r = $this->_doInstallOrUpgrade('upgrade', $pkg);
  361.         return $r;
  362.     }
  363.     // }}}
  365.     // {{{ doUpgradeFromTgz
  366.     /**
  367.      *  do upgrade from local tgz file
  368.      *
  369.      *  @param  string  $pkg_file   package filename
  370.      *  @return true|Ethna_Error
  371.      */
  372.     public function doUpgradeFromTgz($pkg_file)
  373.     {
  374.         $r = $this->_doInstallOrUpgrade('upgrade', $pkg_file); 
  375.         return $r;
  376.     }
  377.     // }}}
  379.     // {{{ isInstalled
  380.     /**
  381.      *  check package installed
  382.      *
  383.      *  @param  string  $package package name
  384.      *  @return bool
  385.      */
  386.     public function isInstalled($package)
  387.     {
  388.         return $this->registry->packageExists($package, $this->channel);
  389.     }
  390.     // }}}
  392.     // {{{ getVersion
  393.     /**
  394.      *  get package version
  395.      *
  396.      *  @param  string  $package package name
  397.      *  @return string  version string
  398.      */
  399.     public function getVersion($package)
  400.     {
  401.         $pobj = $this->registry->getPackage($package, $this->channel);
  402.         return $pobj->getVersion();
  403.     }
  404.     // }}}
  406.     // {{{ getState
  407.     /**
  408.      *  get package version
  409.      *
  410.      *  @param  string  $package package name
  411.      *  @return string  version string
  412.      */
  413.     public function getState($package)
  414.     {
  415.         $pobj = $this->registry->getPackage($package, $this->channel);
  416.         return $pobj->getState();
  417.     }
  418.     // }}}
  420.     // {{{ doUninstall
  421.     /**
  422.      *  do uninstall (packages installed with ethna command)
  423.      *
  424.      *  @return true|Ethna_Error
  425.      */
  426.     public function doUninstall($package)
  427.     {
  428.         $true = true;
  429.         if ($this->isInstalled($package) == false) {
  430.             return Ethna::raiseNotice("{$this->channel}/{$package} is not installed.");
  431.         }
  432.         $r = $this->_run('uninstall', array(), array("{$this->channel}/{$package}"));
  433.         if (PEAR::isError($r)) {
  434.             return $r;
  435.         }
  436.         if ($this->isInstalled($package)) {
  437.             return Ethna::raiseNotice("uninstall failed: {$this->channel}/{$package}");
  438.         }
  439.         return $true;
  440.     }
  441.     // }}}
  443.     // {{{ getPackageNameFromTgz
  444.     /**
  445.      *  get package info from tar/tgz file.
  446.      *
  447.      *  @param  string  $filename   package file name.
  448.      *  @return string  package name
  449.      *  @access public
  450.      *  @static
  451.      */
  452.     public function getPackageNameFromTgz($filename)
  453.     {
  454.         $config = PEAR_Config::singleton();
  455.         $packagefile = new PEAR_PackageFile($config);
  456.         $info = $packagefile->fromTgzFile($filename, PEAR_VALIDATE_NORMAL);
  457.         if (PEAR::isError($info)) {
  458.             return $info;
  459.         }
  460.         $info_array = $info->toArray();
  461.         return $info_array['name'];
  462.     }
  463.     // }}}
  465.     // {{{ getCanonicalPackageName
  466.     /**
  467.      *  get canonical package name (case sensitive)
  468.      *
  469.      *  @param  string  $package    package name.
  470.      *  @return string  canonical name
  471.      *  @access public
  472.      */
  473.     public function getCanonicalPackageName($package)
  474.     {
  475.         if ($this->isInstalled($package) == false) {
  476.             return Ethna::raiseNotice("{$this->channel}/{$package} is not installed.");
  477.         }
  478.         $pobj = $this->registry->getPackage($package, $this->channel);
  479.         $cname = $pobj->getName();
  480.         return $cname;
  481.     }
  482.     // }}}
  484.     // {{{ getInstalledPackageList
  485.     /**
  486.      *  get installed package list
  487.      *
  488.      *  @return array   installed package list
  489.      *  @access public
  490.      */
  491.     public function getInstalledPackageList()
  492.     {
  493.         $ret = array();
  494.         foreach ($this->registry->listPackages($this->channel) as $pkg) {
  495.             $ret[] = $this->getCanonicalPackageName($pkg);
  496.         }
  497.         return $ret;
  498.     }
  499.     // }}}
  501.     // {{{ doInfo
  502.     /**
  503.      *  do info (packages installed with ethna command)
  504.      *
  505.      *  @param  string  $package    package name.
  506.      *  @return true|Ethna_Error
  507.      */
  508.     public function doInfo($package)
  509.     {
  510.         return $this->_run('info', array(), array("{$this->channel}/{$package}"));
  511.     }
  512.     // }}}
  514.     // {{{ doRemoteInfo
  515.     /**
  516.      *  do info (packages installable with ethna command)
  517.      *
  518.      *  @param  string  $package    package name.
  519.      *  @return true|Ethna_Error
  520.      */
  521.     public function doRemoteInfo($package)
  522.     {
  523.         return $this->_run('remote-info', array(), array("{$this->channel}/{$package}"));
  524.     }
  525.     // }}}
  527.     // {{{ doUpgradeAll
  528.     /**
  529.      *  do upgrade-all
  530.      *
  531.      *  @return true|Ethna_Error
  532.      */
  533.     public function doUpgradeAll()
  534.     {
  535.         return $this->_run('upgrade-all', array('channel' => "{$this->channel}"), array());
  536.     }
  537.     // }}}
  539.     // {{{ doList
  540.     /**
  541.      *  do list (packages installed with ethna command)
  542.      *
  543.      *  @return true|Ethna_Error
  544.      */
  545.     public function doList()
  546.     {
  547.         return $this->_run('list', array('channel' => $this->channel), array());
  548.     }
  549.     // }}}
  551.     // {{{ doRemoteList
  552.     /**
  553.      *  do remote-list (packages installable with ethna command)
  554.      *
  555.      *  @return true|Ethna_Error
  556.      */
  557.     public function doRemoteList()
  558.     {
  559.         return $this->_run('remote-list', array('channel' => $this->channel), array());
  560.     }
  561.     // }}}
  563.     // {{{ subroutines.
  564.     /**
  565.      *  run PEAR_Command.
  566.      *
  567.      *  @param  string  $command    command name
  568.      *  @param  array   $options    options
  569.      *  @param  array   $params     parameters
  570.      *  @return true|Ethna_Error
  571.      *  @access private 
  572.      *  @see PEAR_Command_Common::run, etc.
  573.      */
  574.     protected function _run($command, $options, $params)
  575.     {
  576.         if ($this->config === null) {
  577.             return Ethna::raiseError('configuration not initialized.');
  578.         }
  579.  
  580.         $true = true;
  581.  
  582.         $cmd = PEAR_Command::factory($command, $this->config);
  583.         if (PEAR::isError($cmd)) {
  584.             return $cmd;
  585.         }
  586.  
  587.         // pear command options
  588.         if (is_array($this->_pearopt) && count($this->_pearopt) > 0) {
  589.             $pearopts = $this->_getPearOpt($cmd, $command, $this->_pearopt);
  590.             $options = array_merge($pearopts, $options);
  591.         }
  592.  
  593.         $ret = $cmd->run($command, $options, $params);
  594.         if (PEAR::isError($ret)) {
  595.             return $ret;
  596.         }
  597.  
  598.         return $true;
  599.     }
  600.  
  601.     /**
  602.      *  provide yes-or-no dialog.
  603.      *
  604.      *  @return bool
  605.      *  @access public
  606.      */
  607.     public function confirmDialog($message, $default = 'yes')
  608.     {
  609.         $ret = $this->ui->userConfirm($message);
  610.         return $ret;
  611.     }
  612.  
  613.     /**
  614.      *  provide table layout
  615.      *
  616.      *  @param  array   $headline   headline
  617.      *  @param  array   $rows       rows which have the same size as headline's.
  618.      *  @access public
  619.      */
  620.     public function displayTable($caption, $headline, $rows)
  621.     {
  622.         // spacing
  623.         foreach (array_keys($headline) as $k) {
  624.             $headline[$k] = sprintf('% -8s', $headline[$k]);
  625.         }
  626.  
  627.         $data = array('caption'  => $caption,
  628.                       'border'   => true,
  629.                       'headline' => $headline,
  630.                       'data'     => $rows);
  631.         $this->ui->outputData($data);
  632.     }
  633.  
  634.     /**
  635.      *  (experimental)
  636.      *  @access public
  637.      */
  638.     public function setPearOpt($pearopt)
  639.     {
  640.         $this->_pearopt = $pearopt;
  641.     }
  642.  
  643.     /**
  644.      *  (experimental)
  645.      *  @return array
  646.      */
  647.     private function _getPearOpt($cmd_obj, $cmd_str, $opt_array)
  648.     {
  649.         $short_args = $long_args = null;
  650.         PEAR_Command::getGetOptArgs($cmd_str, $short_args, $long_args);
  651.         $opt = new Ethna_Getopt();
  652.         $opt_arg = $opt->getopt($opt_array, $short_args, $long_args);
  653.         if (Ethna::isError($opt_arg)) return array();
  654.         $opts = array();
  655.         foreach ($opt_arg[0] as $tmp) {
  656.             list($opt, $val) = $tmp;
  657.             if ($val === null) $val = true;
  658.             if (strlen($opt) == 1) {
  659.                 $cmd_opts = $cmd_obj->getOptions($cmd_str);
  660.                 foreach ($cmd_opts as $o => $d) {
  661.                     if (isset($d['shortopt']) && $d['shortopt'] == $opt) {
  662.                         $opts[$o] = $val;
  663.                     }
  664.                 }
  665.             } else {
  666.                 if (substr($opt, 0, 2) == '--') $opts[substr($opt, 2)] = $val;
  667.             }
  668.         }
  669.         return $opts;
  670.     }
  671.                 
  672.  
  673.     // }}}
  674. }

Documentation generated on Fri, 11 Nov 2011 03:58:53 +0900 by phpDocumentor 1.4.3