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