[Sommaire] [Imprimer]

   1  <?php
   2  /**
   3   * PEAR_REST_10
   4   *
   5   * PHP versions 4 and 5
   6   *
   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:
   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
  11   * send a note to license@php.net so we can mail you a copy immediately.
  12   *
  13   * @category   pear
  14   * @package    PEAR
  15   * @author     Greg Beaver <cellog@php.net>
  16   * @copyright  1997-2006 The PHP Group
  17   * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  18   * @version    CVS: $Id: 10.php,v 1.40 2006/01/06 04:47:37 cellog Exp $
  19   * @link       http://pear.php.net/package/PEAR
  20   * @since      File available since Release 1.4.0a12
  21   */
  22  
  23  /**
  24   * For downloading REST xml/txt files
  25   */
  26  require_once 'PEAR/REST.php';
  27  
  28  /**
  29   * Implement REST 1.0
  30   *
  31   * @category   pear
  32   * @package    PEAR
  33   * @author     Greg Beaver <cellog@php.net>
  34   * @copyright  1997-2006 The PHP Group
  35   * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  36   * @version    Release: 1.4.11
  37   * @link       http://pear.php.net/package/PEAR
  38   * @since      Class available since Release 1.4.0a12
  39   */
  40  class PEAR_REST_10
  41  {
  42      /**
  43       * @var PEAR_REST
  44       */
  45      var $_rest;
  46      function PEAR_REST_10($config, $options = array())
  47      {
  48          $this->_rest = &new PEAR_REST($config, $options);
  49      }
  50  
  51      function getDownloadURL($base, $packageinfo, $prefstate, $installed)
  52      {
  53          $channel = $packageinfo['channel'];
  54          $package = $packageinfo['package'];
  55          $states = $this->betterStates($prefstate, true);
  56          if (!$states) {
  57              return PEAR::raiseError('"' . $prefstate . '" is not a valid state');
  58          }
  59          $state = $version = null;
  60          if (isset($packageinfo['state'])) {
  61              $state = $packageinfo['state'];
  62          }
  63          if (isset($packageinfo['version'])) {
  64              $version = $packageinfo['version'];
  65          }
  66          $info = $this->_rest->retrieveData($base . 'r/' . strtolower($package) . '/allreleases.xml');
  67          if (PEAR::isError($info)) {
  68              return PEAR::raiseError('No releases available for package "' .
  69                  $channel . '/' . $package . '"');
  70          }
  71          if (!isset($info['r'])) {
  72              return false;
  73          }
  74          $found = false;
  75          $release = false;
  76          if (!is_array($info['r']) || !isset($info['r'][0])) {
  77              $info['r'] = array($info['r']);
  78          }
  79          foreach ($info['r'] as $release) {
  80              if (!isset($this->_rest->_options['force']) && ($installed &&
  81                    version_compare($release['v'], $installed, '<'))) {
  82                  continue;
  83              }
  84              if (isset($state)) {
  85                  if ($release['s'] == $state) {
  86                      $found = true;
  87                      break;
  88                  }
  89              } elseif (isset($version)) {
  90                  if ($release['v'] == $version) {
  91                      $found = true;
  92                      break;
  93                  }
  94              } else {
  95                  if (in_array($release['s'], $states)) {
  96                      $found = true;
  97                      break;
  98                  }
  99              }
 100          }
 101          return $this->_returnDownloadURL($base, $package, $release, $info, $found);
 102      }
 103  
 104      function getDepDownloadURL($base, $xsdversion, $dependency, $deppackage,
 105                                 $prefstate = 'stable', $installed = false)
 106      {
 107          $channel = $dependency['channel'];
 108          $package = $dependency['name'];
 109          $states = $this->betterStates($prefstate, true);
 110          if (!$states) {
 111              return PEAR::raiseError('"' . $prefstate . '" is not a valid state');
 112          }
 113          $state = $version = null;
 114          if (isset($packageinfo['state'])) {
 115              $state = $packageinfo['state'];
 116          }
 117          if (isset($packageinfo['version'])) {
 118              $version = $packageinfo['version'];
 119          }
 120          $info = $this->_rest->retrieveData($base . 'r/' . strtolower($package) . '/allreleases.xml');
 121          if (PEAR::isError($info)) {
 122              return PEAR::raiseError('Package "' . $deppackage['channel'] . '/' . $deppackage['package']
 123                  . '" dependency "' . $channel . '/' . $package . '" has no releases');
 124          }
 125          if (!is_array($info) || !isset($info['r'])) {
 126              return false;
 127          }
 128          $exclude = array();
 129          $min = $max = $recommended = false;
 130          if ($xsdversion == '1.0') {
 131              $pinfo['package'] = $dependency['name'];
 132              $pinfo['channel'] = 'pear.php.net'; // this is always true - don't change this
 133              switch ($dependency['rel']) {
 134                  case 'ge' :
 135                      $min = $dependency['version'];
 136                  break;
 137                  case 'gt' :
 138                      $min = $dependency['version'];
 139                      $exclude = array($dependency['version']);
 140                  break;
 141                  case 'eq' :
 142                      $recommended = $dependency['version'];
 143                  break;
 144                  case 'lt' :
 145                      $max = $dependency['version'];
 146                      $exclude = array($dependency['version']);
 147                  break;
 148                  case 'le' :
 149                      $max = $dependency['version'];
 150                  break;
 151                  case 'ne' :
 152                      $exclude = array($dependency['version']);
 153                  break;
 154              }
 155          } else {
 156              $pinfo['package'] = $dependency['name'];
 157              $min = isset($dependency['min']) ? $dependency['min'] : false;
 158              $max = isset($dependency['max']) ? $dependency['max'] : false;
 159              $recommended = isset($dependency['recommended']) ?
 160                  $dependency['recommended'] : false;
 161              if (isset($dependency['exclude'])) {
 162                  if (!isset($dependency['exclude'][0])) {
 163                      $exclude = array($dependency['exclude']);
 164                  }
 165              }
 166          }
 167          $found = false;
 168          $release = false;
 169          if (!is_array($info['r']) || !isset($info['r'][0])) {
 170              $info['r'] = array($info['r']);
 171          }
 172          foreach ($info['r'] as $release) {
 173              if (!isset($this->_rest->_options['force']) && ($installed &&
 174                    version_compare($release['v'], $installed, '<'))) {
 175                  continue;
 176              }
 177              if (in_array($release['v'], $exclude)) { // skip excluded versions
 178                  continue;
 179              }
 180              // allow newer releases to say "I'm OK with the dependent package"
 181              if ($xsdversion == '2.0' && isset($release['co'])) {
 182                  if (!is_array($release['co']) || !isset($release['co'][0])) {
 183                      $release['co'] = array($release['co']);
 184                  }
 185                  foreach ($release['co'] as $entry) {
 186                      if (isset($entry['x']) && !is_array($entry['x'])) {
 187                          $entry['x'] = array($entry['x']);
 188                      } elseif (!isset($entry['x'])) {
 189                          $entry['x'] = array();
 190                      }
 191                      if ($entry['c'] == $deppackage['channel'] &&
 192                            strtolower($entry['p']) == strtolower($deppackage['package']) &&
 193                            version_compare($deppackage['version'], $entry['min'], '>=') &&
 194                            version_compare($deppackage['version'], $entry['max'], '<=') &&
 195                            !in_array($release['v'], $entry['x'])) {
 196                          $recommended = $release['v'];
 197                          break;
 198                      }
 199                  }
 200              }
 201              if ($recommended) {
 202                  if ($release['v'] != $recommended) { // if we want a specific
 203                      // version, then skip all others
 204                      continue;
 205                  } else {
 206                      if (!in_array($release['s'], $states)) {
 207                          // the stability is too low, but we must return the
 208                          // recommended version if possible
 209                          return $this->_returnDownloadURL($base, $package, $release, $info, true);
 210                      }
 211                  }
 212              }
 213              if ($min && version_compare($release['v'], $min, 'lt')) { // skip too old versions
 214                  continue;
 215              }
 216              if ($max && version_compare($release['v'], $max, 'gt')) { // skip too new versions
 217                  continue;
 218              }
 219              if ($installed && version_compare($release['v'], $installed, '<')) {
 220                  continue;
 221              }
 222              if (in_array($release['s'], $states)) { // if in the preferred state...
 223                  $found = true; // ... then use it
 224                  break;
 225              }
 226          }
 227          return $this->_returnDownloadURL($base, $package, $release, $info, $found);
 228      }
 229  
 230      function _returnDownloadURL($base, $package, $release, $info, $found)
 231      {
 232          if (!$found) {
 233              $release = $info['r'][0];
 234          }
 235          $releaseinfo = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package) . '/' . 
 236              $release['v'] . '.xml');
 237          if (PEAR::isError($releaseinfo)) {
 238              return PEAR::raiseError('Package "' . $package . '" Version "' . $release['v'] .
 239                  '" does not have REST xml available');
 240          }
 241          $packagexml = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package) . '/' .
 242              'deps.' . $release['v'] . '.txt', false, true);
 243          if (PEAR::isError($packagexml)) {
 244              return PEAR::raiseError('Package "' . $package . '" Version "' . $release['v'] .
 245                  '" does not have REST dependency information available');
 246          }
 247          $packagexml = unserialize($packagexml);
 248          if (!$packagexml) {
 249              $packagexml = array();
 250          }
 251          $allinfo = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 252              '/allreleases.xml');
 253          if (!is_array($allinfo['r']) || !isset($allinfo['r'][0])) {
 254              $allinfo['r'] = array($allinfo['r']);
 255          }
 256          $compatible = false;
 257          foreach ($allinfo['r'] as $release) {
 258              if ($release['v'] != $releaseinfo['v']) {
 259                  continue;
 260              }
 261              if (!isset($release['co'])) {
 262                  break;
 263              }
 264              $compatible = array();
 265              if (!is_array($release['co']) || !isset($release['co'][0])) {
 266                  $release['co'] = array($release['co']);
 267              }
 268              foreach ($release['co'] as $entry) {
 269                  $comp = array();
 270                  $comp['name'] = $entry['p'];
 271                  $comp['channel'] = $entry['c'];
 272                  $comp['min'] = $entry['min'];
 273                  $comp['max'] = $entry['max'];
 274                  if (isset($entry['x']) && !is_array($entry['x'])) {
 275                      $comp['exclude'] = $entry['x'];
 276                  }
 277                  $compatible[] = $comp;
 278              }
 279              if (count($compatible) == 1) {
 280                  $compatible = $compatible[0];
 281              }
 282              break;
 283          }
 284          if ($found) {
 285              return 
 286                  array('version' => $releaseinfo['v'],
 287                        'info' => $packagexml,
 288                        'package' => $releaseinfo['p']['_content'],
 289                        'stability' => $releaseinfo['st'],
 290                        'url' => $releaseinfo['g'],
 291                        'compatible' => $compatible);
 292          } else {
 293              return
 294                  array('version' => $releaseinfo['v'],
 295                        'package' => $releaseinfo['p']['_content'],
 296                        'stability' => $releaseinfo['st'],
 297                        'info' => $packagexml,
 298                        'compatible' => $compatible);
 299          }
 300      }
 301  
 302      function listPackages($base)
 303      {
 304          $packagelist = $this->_rest->retrieveData($base . 'p/packages.xml');
 305          if (PEAR::isError($packagelist)) {
 306              return $packagelist;
 307          }
 308          if (!is_array($packagelist) || !isset($packagelist['p'])) {
 309              return array();
 310          }
 311          if (!is_array($packagelist['p'])) {
 312              $packagelist['p'] = array($packagelist['p']);
 313          }
 314          return $packagelist['p'];
 315      }
 316  
 317      function listAll($base, $dostable, $basic = true, $searchpackage = false, $searchsummary = false)
 318      {
 319          $packagelist = $this->_rest->retrieveData($base . 'p/packages.xml');
 320          if (PEAR::isError($packagelist)) {
 321              return $packagelist;
 322          }
 323          if ($this->_rest->config->get('verbose') > 0) {
 324              $ui = &PEAR_Frontend::singleton();
 325              $ui->log('Retrieving data...0%', false);
 326          }
 327          $ret = array();
 328          if (!is_array($packagelist) || !isset($packagelist['p'])) {
 329              return $ret;
 330          }
 331          if (!is_array($packagelist['p'])) {
 332              $packagelist['p'] = array($packagelist['p']);
 333          }
 334          PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 335          $next = .1;
 336          foreach ($packagelist['p'] as $progress => $package) {
 337              if ($this->_rest->config->get('verbose') > 0) {
 338                  if ($progress / count($packagelist['p']) >= $next) {
 339                      if ($next == .5) {
 340                          $ui->log('50%', false);
 341                      } else {
 342                          $ui->log('.', false);
 343                      }
 344                      $next += .1;
 345                  }
 346              }
 347              if ($basic) { // remote-list command
 348                  if ($dostable) {
 349                      $latest = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 350                          '/stable.txt');
 351                  } else {
 352                      $latest = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 353                          '/latest.txt');
 354                  }
 355                  if (PEAR::isError($latest)) {
 356                      $latest = false;
 357                  }
 358                  $info = array('stable' => $latest);
 359              } else { // list-all command
 360                  $inf = $this->_rest->retrieveData($base . 'p/' . strtolower($package) . '/info.xml');
 361                  if (PEAR::isError($inf)) {
 362                      PEAR::popErrorHandling();
 363                      return $inf;
 364                  }
 365                  if ($searchpackage) {
 366                      $found = (!empty($searchpackage) && stristr($package, $searchpackage) !== false);
 367                      if (!$found && !(isset($searchsummary) && !empty($searchsummary)
 368                          && (stristr($inf['s'], $searchsummary) !== false
 369                              || stristr($inf['d'], $searchsummary) !== false)))
 370                      {
 371                          continue;
 372                      };
 373                  }
 374                  $releases = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 375                      '/allreleases.xml');
 376                  if (PEAR::isError($releases)) {
 377                      continue;
 378                  }
 379                  if (!isset($releases['r'][0])) {
 380                      $releases['r'] = array($releases['r']);
 381                  }
 382                  unset($latest);
 383                  unset($unstable);
 384                  unset($stable);
 385                  unset($state);
 386                  foreach ($releases['r'] as $release) {
 387                      if (!isset($latest)) {
 388                          if ($dostable && $release['s'] == 'stable') {
 389                              $latest = $release['v'];
 390                              $state = 'stable';
 391                          }
 392                          if (!$dostable) {
 393                              $latest = $release['v'];
 394                              $state = $release['s'];
 395                          }
 396                      }
 397                      if (!isset($stable) && $release['s'] == 'stable') {
 398                          $stable = $release['v'];
 399                          if (!isset($unstable)) {
 400                              $unstable = $stable;
 401                          }
 402                      }
 403                      if (!isset($unstable) && $release['s'] != 'stable') {
 404                          $latest = $unstable = $release['v'];
 405                          $state = $release['s'];
 406                      }
 407                      if (isset($latest) && !isset($state)) {
 408                          $state = $release['s'];
 409                      }
 410                      if (isset($latest) && isset($stable) && isset($unstable)) {
 411                          break;
 412                      }
 413                  }
 414                  $deps = array();
 415                  if (!isset($unstable)) {
 416                      $unstable = false;
 417                      $state = 'stable';
 418                      if (isset($stable)) {
 419                          $latest = $unstable = $stable;
 420                      }
 421                  } else {
 422                      $latest = $unstable;
 423                  }
 424                  if (!isset($latest)) {
 425                      $latest = false;
 426                  }
 427                  if ($latest) {
 428                      $d = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package) . '/deps.' .
 429                          $latest . '.txt');
 430                      if (!PEAR::isError($d)) {
 431                          $d = unserialize($d);
 432                          if ($d) {
 433                              if (isset($d['required'])) {
 434                                  if (!class_exists('PEAR_PackageFile_v2')) {
 435                                      require_once 'PEAR/PackageFile/v2.php';
 436                                  }
 437                                  if (!isset($pf)) {
 438                                      $pf = new PEAR_PackageFile_v2;
 439                                  }
 440                                  $pf->setDeps($d);
 441                                  $tdeps = $pf->getDeps();
 442                              } else {
 443                                  $tdeps = $d;
 444                              }
 445                              foreach ($tdeps as $dep) {
 446                                  if ($dep['type'] !== 'pkg') {
 447                                      continue;
 448                                  }
 449                                  $deps[] = $dep;
 450                              }
 451                          }
 452                      }
 453                  }
 454                  if (!isset($stable)) {
 455                      $stable = '-n/a-';
 456                  }
 457                  if (!$searchpackage) {
 458                      $info = array('stable' => $latest, 'summary' => $inf['s'], 'description' =>
 459                          $inf['d'], 'deps' => $deps, 'category' => $inf['ca']['_content'],
 460                          'unstable' => $unstable, 'state' => $state);
 461                  } else {
 462                      $info = array('stable' => $stable, 'summary' => $inf['s'], 'description' =>
 463                          $inf['d'], 'deps' => $deps, 'category' => $inf['ca']['_content'],
 464                          'unstable' => $unstable, 'state' => $state);
 465                  }
 466              }
 467              $ret[$package] = $info;
 468          }
 469          PEAR::popErrorHandling();
 470          return $ret;
 471      }
 472  
 473      function listLatestUpgrades($base, $state, $installed, $channel, &$reg)
 474      {
 475          $packagelist = $this->_rest->retrieveData($base . 'p/packages.xml');
 476          if (PEAR::isError($packagelist)) {
 477              return $packagelist;
 478          }
 479          $ret = array();
 480          if (!is_array($packagelist) || !isset($packagelist['p'])) {
 481              return $ret;
 482          }
 483          if (!is_array($packagelist['p'])) {
 484              $packagelist['p'] = array($packagelist['p']);
 485          }
 486          if ($state) {
 487              $states = $this->betterStates($state, true);
 488          }
 489          foreach ($packagelist['p'] as $package) {
 490              if (!isset($installed[strtolower($package)])) {
 491                  continue;
 492              }
 493              $inst_version = $reg->packageInfo($package, 'version', $channel);
 494              PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 495              $info = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 496                  '/allreleases.xml');
 497              PEAR::popErrorHandling();
 498              if (PEAR::isError($info)) {
 499                  continue; // no remote releases
 500              }
 501              if (!isset($info['r'])) {
 502                  continue;
 503              }
 504              $found = false;
 505              $release = false;
 506              if (!is_array($info['r']) || !isset($info['r'][0])) {
 507                  $info['r'] = array($info['r']);
 508              }
 509              foreach ($info['r'] as $release) {
 510                  if ($inst_version && version_compare($release['v'], $inst_version, '<=')) {
 511                      continue;
 512                  }
 513                  if ($state) {
 514                      if (in_array($release['s'], $states)) {
 515                          $found = true;
 516                          break;
 517                      }
 518                  } else {
 519                      $found = true;
 520                      break;
 521                  }
 522              }
 523              if (!$found) {
 524                  continue;
 525              }
 526              $relinfo = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package) . '/' . 
 527                  $release['v'] . '.xml');
 528              if (PEAR::isError($relinfo)) {
 529                  return $relinfo;
 530              }
 531              $ret[$package] = array(
 532                      'version' => $release['v'],
 533                      'state' => $release['s'],
 534                      'filesize' => $relinfo['f'],
 535                  );
 536          }
 537          return $ret;
 538      }
 539  
 540      function packageInfo($base, $package)
 541      {
 542          PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 543          $pinfo = $this->_rest->retrieveData($base . 'p/' . strtolower($package) . '/info.xml');
 544          if (PEAR::isError($pinfo)) {
 545              PEAR::popErrorHandling();
 546              return PEAR::raiseError('Unknown package: "' . $package . '" (Debug: ' .
 547                  $pinfo->getMessage() . ')');
 548          }
 549          $releases = array();
 550          $allreleases = $this->_rest->retrieveData($base . 'r/' . strtolower($package) .
 551              '/allreleases.xml');
 552          if (!PEAR::isError($allreleases)) {
 553              if (!class_exists('PEAR_PackageFile_v2')) {
 554                  require_once 'PEAR/PackageFile/v2.php';
 555              }
 556              if (!is_array($allreleases['r'])) {
 557                  $allreleases['r'] = array($allreleases['r']);
 558              }
 559              $pf = new PEAR_PackageFile_v2;
 560              foreach ($allreleases['r'] as $release) {
 561                  $ds = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package) . '/deps.' .
 562                      $release['v'] . '.txt');
 563                  if (PEAR::isError($ds)) {
 564                      continue;
 565                  }
 566                  if (!isset($latest)) {
 567                      $latest = $release['v'];
 568                  }
 569                  $pf->setDeps(unserialize($ds));
 570                  $ds = $pf->getDeps();
 571                  $info = $this->_rest->retrieveCacheFirst($base . 'r/' . strtolower($package)
 572                      . '/' . $release['v'] . '.xml');
 573                  if (PEAR::isError($info)) {
 574                      continue;
 575                  }
 576                  $releases[$release['v']] = array(
 577                      'doneby' => $info['m'],
 578                      'license' => $info['l'],
 579                      'summary' => $info['s'],
 580                      'description' => $info['d'],
 581                      'releasedate' => $info['da'],
 582                      'releasenotes' => $info['n'],
 583                      'state' => $release['s'],
 584                      'deps' => $ds ? $ds : array(),
 585                  );
 586              }
 587          } else {
 588              $latest = '';
 589          }
 590          PEAR::popErrorHandling();
 591          return array(
 592              'name' => $pinfo['n'],
 593              'channel' => $pinfo['c'],
 594              'category' => $pinfo['ca']['_content'],
 595              'stable' => $latest,
 596              'license' => $pinfo['l'],
 597              'summary' => $pinfo['s'],
 598              'description' => $pinfo['d'],
 599              'releases' => $releases,
 600              );
 601      }
 602  
 603      /**
 604       * Return an array containing all of the states that are more stable than
 605       * or equal to the passed in state
 606       *
 607       * @param string Release state
 608       * @param boolean Determines whether to include $state in the list
 609       * @return false|array False if $state is not a valid release state
 610       */
 611      function betterStates($state, $include = false)
 612      {
 613          static $states = array('snapshot', 'devel', 'alpha', 'beta', 'stable');
 614          $i = array_search($state, $states);
 615          if ($i === false) {
 616              return false;
 617          }
 618          if ($include) {
 619              $i--;
 620          }
 621          return array_slice($states, $i + 1);
 622      }
 623  }
 624  ?>