includes/GitInfo.php

   1 <?php
   2 /**
   3  * A class to help return information about a git repo MediaWiki may be inside
   4  * This is used by Special:Version and is also useful for the LocalSettings.php
   5  * of anyone working on large branches in git to setup config that show up only
   6  * when specific branches are currently checked out.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  * http://www.gnu.org/copyleft/gpl.html
  22  *
  23  * @file
  24  */
  25
  26 use MediaWiki\Shell\Shell;
  27
  28 class GitInfo {
  29
  30         /**
  31          * Singleton for the repo at $IP
  32          */
  33         protected static $repo = null;
  34
  35         /**
  36          * Location of the .git directory
  37          */
  38         protected $basedir;
  39
  40         /**
  41          * Location of the repository
  42          */
  43         protected $repoDir;
  44
  45         /**
  46          * Path to JSON cache file for pre-computed git information.
  47          */
  48         protected $cacheFile;
  49
  50         /**
  51          * Cached git information.
  52          */
  53         protected $cache = [];
  54
  55         /**
  56          * @var array|false Map of repo URLs to viewer URLs. Access via static method getViewers().
  57          */
  58         private static $viewers = false;
  59
  60         /**
  61          * @param string $repoDir The root directory of the repo where .git can be found
  62          * @param bool $usePrecomputed Use precomputed information if available
  63          * @see precomputeValues
  64          */
  65         public function __construct( $repoDir, $usePrecomputed = true ) {
  66                 $this->repoDir = $repoDir;
  67                 $this->cacheFile = self::getCacheFilePath( $repoDir );
  68                 wfDebugLog( 'gitinfo',
  69                         "Candidate cacheFile={$this->cacheFile} for {$repoDir}"
  70                 );
  71                 if ( $usePrecomputed &&
  72                         $this->cacheFile !== null &&
  73                         is_readable( $this->cacheFile )
  74                 ) {
  75                         $this->cache = FormatJson::decode(
  76                                 file_get_contents( $this->cacheFile ),
  77                                 true
  78                         );
  79                         wfDebugLog( 'gitinfo', "Loaded git data from cache for {$repoDir}" );
  80                 }
  81
  82                 if ( !$this->cacheIsComplete() ) {
  83                         wfDebugLog( 'gitinfo', "Cache incomplete for {$repoDir}" );
  84                         $this->basedir = $repoDir . DIRECTORY_SEPARATOR . '.git';
  85                         if ( is_readable( $this->basedir ) && !is_dir( $this->basedir ) ) {
  86                                 $GITfile = file_get_contents( $this->basedir );
  87                                 if ( strlen( $GITfile ) > 8 &&
  88                                         substr( $GITfile, 0, 8 ) === 'gitdir: '
  89                                 ) {
  90                                         $path = rtrim( substr( $GITfile, 8 ), "\r\n" );
  91                                         if ( $path[0] === '/' || substr( $path, 1, 1 ) === ':' ) {
  92                                                 // Path from GITfile is absolute
  93                                                 $this->basedir = $path;
  94                                         } else {
  95                                                 $this->basedir = $repoDir . DIRECTORY_SEPARATOR . $path;
  96                                         }
  97                                 }
  98                         }
  99                 }
 100         }
 101
 102         /**
 103          * Compute the path to the cache file for a given directory.
 104          *
 105          * @param string $repoDir The root directory of the repo where .git can be found
 106          * @return string Path to GitInfo cache file in $wgGitInfoCacheDirectory or
 107          * fallback in the extension directory itself
 108          * @since 1.24
 109          */
 110         protected static function getCacheFilePath( $repoDir ) {
 111                 global $IP, $wgGitInfoCacheDirectory;
 112
 113                 if ( $wgGitInfoCacheDirectory ) {
 114                         // Convert both $IP and $repoDir to canonical paths to protect against
 115                         // $IP having changed between the settings files and runtime.
 116                         $realIP = realpath( $IP );
 117                         $repoName = realpath( $repoDir );
 118                         if ( $repoName === false ) {
 119                                 // Unit tests use fake path names
 120                                 $repoName = $repoDir;
 121                         }
 122                         if ( strpos( $repoName, $realIP ) === 0 ) {
 123                                 // Strip $IP from path
 124                                 $repoName = substr( $repoName, strlen( $realIP ) );
 125                         }
 126                         // Transform path to git repo to something we can safely embed in
 127                         // a filename
 128                         $repoName = strtr( $repoName, DIRECTORY_SEPARATOR, '-' );
 129                         $fileName = 'info' . $repoName . '.json';
 130                         $cachePath = "{$wgGitInfoCacheDirectory}/{$fileName}";
 131                         if ( is_readable( $cachePath ) ) {
 132                                 return $cachePath;
 133                         }
 134                 }
 135
 136                 return "$repoDir/gitinfo.json";
 137         }
 138
 139         /**
 140          * Get the singleton for the repo at $IP
 141          *
 142          * @return GitInfo
 143          */
 144         public static function repo() {
 145                 if ( is_null( self::$repo ) ) {
 146                         global $IP;
 147                         self::$repo = new self( $IP );
 148                 }
 149                 return self::$repo;
 150         }
 151
 152         /**
 153          * Check if a string looks like a hex encoded SHA1 hash
 154          *
 155          * @param string $str The string to check
 156          * @return bool Whether or not the string looks like a SHA1
 157          */
 158         public static function isSHA1( $str ) {
 159                 return (bool)preg_match( '/^[0-9A-F]{40}$/i', $str );
 160         }
 161
 162         /**
 163          * Get the HEAD of the repo (without any opening "ref: ")
 164          *
 165          * @return string|bool The HEAD (git reference or SHA1) or false
 166          */
 167         public function getHead() {
 168                 if ( !isset( $this->cache['head'] ) ) {
 169                         $headFile = "{$this->basedir}/HEAD";
 170                         $head = false;
 171
 172                         if ( is_readable( $headFile ) ) {
 173                                 $head = file_get_contents( $headFile );
 174
 175                                 if ( preg_match( "/ref: (.*)/", $head, $m ) ) {
 176                                         $head = rtrim( $m[1] );
 177                                 } else {
 178                                         $head = rtrim( $head );
 179                                 }
 180                         }
 181                         $this->cache['head'] = $head;
 182                 }
 183                 return $this->cache['head'];
 184         }
 185
 186         /**
 187          * Get the SHA1 for the current HEAD of the repo
 188          *
 189          * @return string|bool A SHA1 or false
 190          */
 191         public function getHeadSHA1() {
 192                 if ( !isset( $this->cache['headSHA1'] ) ) {
 193                         $head = $this->getHead();
 194                         $sha1 = false;
 195
 196                         // If detached HEAD may be a SHA1
 197                         if ( self::isSHA1( $head ) ) {
 198                                 $sha1 = $head;
 199                         } else {
 200                                 // If not a SHA1 it may be a ref:
 201                                 $refFile = "{$this->basedir}/{$head}";
 202                                 $packedRefs = "{$this->basedir}/packed-refs";
 203                                 $headRegex = preg_quote( $head, '/' );
 204                                 if ( is_readable( $refFile ) ) {
 205                                         $sha1 = rtrim( file_get_contents( $refFile ) );
 206                                 } elseif ( is_readable( $packedRefs ) &&
 207                                         preg_match( "/^([0-9A-Fa-f]{40}) $headRegex$/m", file_get_contents( $packedRefs ), $matches )
 208                                 ) {
 209                                         $sha1 = $matches[1];
 210                                 }
 211                         }
 212                         $this->cache['headSHA1'] = $sha1;
 213                 }
 214                 return $this->cache['headSHA1'];
 215         }
 216
 217         /**
 218          * Get the commit date of HEAD entry of the git code repository
 219          *
 220          * @since 1.22
 221          * @return int|bool Commit date (UNIX timestamp) or false
 222          */
 223         public function getHeadCommitDate() {
 224                 global $wgGitBin;
 225
 226                 if ( !isset( $this->cache['headCommitDate'] ) ) {
 227                         $date = false;
 228                         if ( is_file( $wgGitBin ) &&
 229                                 is_executable( $wgGitBin ) &&
 230                                 !Shell::isDisabled() &&
 231                                 $this->getHead() !== false
 232                         ) {
 233                                 $cmd = [
 234                                         $wgGitBin,
 235                                         'show',
 236                                         '-s',
 237                                         '--format=format:%ct',
 238                                         'HEAD',
 239                                 ];
 240                                 $gitDir = realpath( $this->basedir );
 241                                 $result = Shell::command( $cmd )
 242                                         ->environment( [ 'GIT_DIR' => $gitDir ] )
 243                                         ->restrict( Shell::RESTRICT_DEFAULT | Shell::NO_NETWORK )
 244                                         ->whitelistPaths( [ $gitDir, $this->repoDir ] )
 245                                         ->execute();
 246
 247                                 if ( $result->getExitCode() === 0 ) {
 248                                         $date = (int)$result->getStdout();
 249                                 }
 250                         }
 251                         $this->cache['headCommitDate'] = $date;
 252                 }
 253                 return $this->cache['headCommitDate'];
 254         }
 255
 256         /**
 257          * Get the name of the current branch, or HEAD if not found
 258          *
 259          * @return string|bool The branch name, HEAD, or false
 260          */
 261         public function getCurrentBranch() {
 262                 if ( !isset( $this->cache['branch'] ) ) {
 263                         $branch = $this->getHead();
 264                         if ( $branch &&
 265                                 preg_match( "#^refs/heads/(.*)$#", $branch, $m )
 266                         ) {
 267                                 $branch = $m[1];
 268                         }
 269                         $this->cache['branch'] = $branch;
 270                 }
 271                 return $this->cache['branch'];
 272         }
 273
 274         /**
 275          * Get an URL to a web viewer link to the HEAD revision.
 276          *
 277          * @return string|bool String if a URL is available or false otherwise
 278          */
 279         public function getHeadViewUrl() {
 280                 $url = $this->getRemoteUrl();
 281                 if ( $url === false ) {
 282                         return false;
 283                 }
 284                 foreach ( self::getViewers() as $repo => $viewer ) {
 285                         $pattern = '#^' . $repo . '$#';
 286                         if ( preg_match( $pattern, $url, $matches ) ) {
 287                                 $viewerUrl = preg_replace( $pattern, $viewer, $url );
 288                                 $headSHA1 = $this->getHeadSHA1();
 289                                 $replacements = [
 290                                         '%h' => substr( $headSHA1, 0, 7 ),
 291                                         '%H' => $headSHA1,
 292                                         '%r' => urlencode( $matches[1] ),
 293                                         '%R' => $matches[1],
 294                                 ];
 295                                 return strtr( $viewerUrl, $replacements );
 296                         }
 297                 }
 298                 return false;
 299         }
 300
 301         /**
 302          * Get the URL of the remote origin.
 303          * @return string|bool String if a URL is available or false otherwise.
 304          */
 305         protected function getRemoteUrl() {
 306                 if ( !isset( $this->cache['remoteURL'] ) ) {
 307                         $config = "{$this->basedir}/config";
 308                         $url = false;
 309                         if ( is_readable( $config ) ) {
 310                                 Wikimedia\suppressWarnings();
 311                                 $configArray = parse_ini_file( $config, true );
 312                                 Wikimedia\restoreWarnings();
 313                                 $remote = false;
 314
 315                                 // Use the "origin" remote repo if available or any other repo if not.
 316                                 if ( isset( $configArray['remote origin'] ) ) {
 317                                         $remote = $configArray['remote origin'];
 318                                 } elseif ( is_array( $configArray ) ) {
 319                                         foreach ( $configArray as $sectionName => $sectionConf ) {
 320                                                 if ( substr( $sectionName, 0, 6 ) == 'remote' ) {
 321                                                         $remote = $sectionConf;
 322                                                 }
 323                                         }
 324                                 }
 325
 326                                 if ( $remote !== false && isset( $remote['url'] ) ) {
 327                                         $url = $remote['url'];
 328                                 }
 329                         }
 330                         $this->cache['remoteURL'] = $url;
 331                 }
 332                 return $this->cache['remoteURL'];
 333         }
 334
 335         /**
 336          * Check to see if the current cache is fully populated.
 337          *
 338          * Note: This method is public only to make unit testing easier. There's
 339          * really no strong reason that anything other than a test should want to
 340          * call this method.
 341          *
 342          * @return bool True if all expected cache keys exist, false otherwise
 343          */
 344         public function cacheIsComplete() {
 345                 return isset( $this->cache['head'] ) &&
 346                         isset( $this->cache['headSHA1'] ) &&
 347                         isset( $this->cache['headCommitDate'] ) &&
 348                         isset( $this->cache['branch'] ) &&
 349                         isset( $this->cache['remoteURL'] );
 350         }
 351
 352         /**
 353          * Precompute and cache git information.
 354          *
 355          * Creates a JSON file in the cache directory associated with this
 356          * GitInfo instance. This cache file will be used by subsequent GitInfo objects referencing
 357          * the same directory to avoid needing to examine the .git directory again.
 358          *
 359          * @since 1.24
 360          */
 361         public function precomputeValues() {
 362                 if ( $this->cacheFile !== null ) {
 363                         // Try to completely populate the cache
 364                         $this->getHead();
 365                         $this->getHeadSHA1();
 366                         $this->getHeadCommitDate();
 367                         $this->getCurrentBranch();
 368                         $this->getRemoteUrl();
 369
 370                         if ( !$this->cacheIsComplete() ) {
 371                                 wfDebugLog( 'gitinfo',
 372                                         "Failed to compute GitInfo for \"{$this->basedir}\""
 373                                 );
 374                                 return;
 375                         }
 376
 377                         $cacheDir = dirname( $this->cacheFile );
 378                         if ( !file_exists( $cacheDir ) &&
 379                                 !wfMkdirParents( $cacheDir, null, __METHOD__ )
 380                         ) {
 381                                 throw new MWException( "Unable to create GitInfo cache \"{$cacheDir}\"" );
 382                         }
 383
 384                         file_put_contents( $this->cacheFile, FormatJson::encode( $this->cache ) );
 385                 }
 386         }
 387
 388         /**
 389          * @see self::getHeadSHA1
 390          * @return string
 391          */
 392         public static function headSHA1() {
 393                 return self::repo()->getHeadSHA1();
 394         }
 395
 396         /**
 397          * @see self::getCurrentBranch
 398          * @return string
 399          */
 400         public static function currentBranch() {
 401                 return self::repo()->getCurrentBranch();
 402         }
 403
 404         /**
 405          * @see self::getHeadViewUrl()
 406          * @return bool|string
 407          */
 408         public static function headViewUrl() {
 409                 return self::repo()->getHeadViewUrl();
 410         }
 411
 412         /**
 413          * Gets the list of repository viewers
 414          * @return array
 415          */
 416         protected static function getViewers() {
 417                 global $wgGitRepositoryViewers;
 418
 419                 if ( self::$viewers === false ) {
 420                         self::$viewers = $wgGitRepositoryViewers;
 421                         Hooks::run( 'GitViewers', [ &self::$viewers ] );
 422                 }
 423
 424                 return self::$viewers;
 425         }
 426 }